自定义Hive Sql Job分析工具

最新推荐文章于 2022-04-19 15:55:45 发布
最新推荐文章于 2022-04-19 15:55:45 发布
阅读量283 收藏 1
点赞数
文章标签： 大数据 java 开发工具

前言

我们都知道,在大数据领域,Hive的出现帮我降低了许多使用Hadoop书写方式的学习成本.使用用户可以使用类似Sql的语法规则写明查询语句,从hive表数据中查询目标数据.最为重要的是这些sql语句会最终转化为map reduce作业进行处理.这也是Hive最强大的地方.可以简单的理解为Hive就是依托在Hadoop上的1个壳.但是这里有一点点小小的不同,不是每段hive查询sql语句与最后生成的job一一对应,如果你的这段sql是一个大sql,他在转化掉之后,会衍生出许多小job,这些小job是独立存在运行的,以不同的job名称进行区别,但是也会保留公共的job名称.所以一个问题来了,对于超级长的hive sql语句,我想查看到底是哪段子sql花费了我大量的执行时间,在JobHistory上只有每个子Job的运行时间,没有子Job对应的sql语句,一旦这个功能有了之后,就会帮助我们迅速的定位到问题所在.


Hive子Job中的Sql

OK,带着上述的目标,我们要想分析出到底哪段子sql所衍生的job运行时间更长,就要先知道这些sql到底在存在与哪里.在前面的描述中,已经提到了,Hive是依托于Hadoop,自然Hive提交的job信息也是保存在Hadoop的HDFS上的.在联想一下JobHistory中的各个文件类型.你应该会发现带有下面后缀的文件存在.


我们发现里面包含了之前分析过的.jhist文件,还有带conf字符的.xml格式文件,从文件名上来看就是job提交时的一些配置信息,然后我们用vim命令查阅conf.xml后缀的文件,看看里面是不是有我们想要的hive qury string 这样的属性


OK,目标算是找到了,这的确就是我们想要的属性.说明这样的信息的确是存在的,后面的操作就是怎么去解析这段有用的信息了.


程序工具分析Hive Sql Job

知道了目标数据源,我们能想到的最简单快速的方法就是逐行解析文件,做做文本匹配,筛选关键信息.这些代码谁都会写,首先要传入一个HDFS目录地址,这个是在JobHistory的存储目录上加上一个具体日期目录,这段解析程序在文章的末尾会加上.下面列举在调试分析程序时遇到的一些问题,这个还是比较有用的.

1.hive sql中的中文导致解析出现乱码

这个又是非常讨厌的java解析出现乱码的原因,因为考虑到sql中存在中文注释,而Hadoop在存中文的时候都是用utf8的编码方式,所以读出文件数据后进行一次转utf-8编码方式的处理,就是下面所示代码.

[java] view plain copy print ?
  1. ...
  2. fileSystem=path.getFileSystem(newConfiguration());
  3. in=fileSystem.open(path);
  4. InputStreamReaderisr;
  5. BufferedReaderbr;
  7. isr=newInputStreamReader(in,"UTF-8");
  8. br=newBufferedReader(isr);
  10. while((str=br.readLine())!=null){
  11. ...

2.单线程解析文件速度过慢

之前在测试环境中做文件解析看不出真实效果,文件一下解析就OK了,但是到真实环境中,多达几万个job文件,程序马上就吃不消了,算上解析文件,再把结果写入mysql,耗时达到60多分钟,后面改成了多线程的方式,后来开到10个线程去跑,速度才快了许多.


3.结果数据写入MySql过慢

后来处理速度是上去了,但是写入sql速度过慢,比如说,我有一次测试,开10个线程区解析,花了8分钟就解析好了几万个文件数据,但是插入数据库花了20分钟左右,而且量也就几万条语句.后来改成了批处理的方式,效果并没有什么大的改变,这个慢的问题具体并没有被解决掉,怀疑可能是因有些语句中存在超长的hive sql语句导致的.


下面是程序的主要分析代码,分为工具类代码,和解析线程类,代码全部链接再此处:https://github.com/linyiqun/yarn-jobhistory-crawler/tree/master/jobHiveSqlAnalyse

主工具代码

[java] view plain copy print ?
  1. packageorg.apache.hadoop.mapreduce.v2.hs.tool.sqlanalyse;
  3. importjava.io.BufferedReader;
  4. importjava.io.FileNotFoundException;
  5. importjava.io.IOException;
  6. importjava.io.InputStream;
  7. importjava.io.InputStreamReader;
  8. importjava.io.PrintStream;
  9. importjava.util.ArrayList;
  10. importjava.util.HashMap;
  11. importjava.util.LinkedList;
  12. importjava.util.List;
  13. importjava.util.Map.Entry;
  15. importorg.apache.hadoop.conf.Configuration;
  16. importorg.apache.hadoop.fs.FSDataInputStream;
  17. importorg.apache.hadoop.fs.FileContext;
  18. importorg.apache.hadoop.fs.FileStatus;
  19. importorg.apache.hadoop.fs.FileSystem;
  20. importorg.apache.hadoop.fs.Path;
  21. importorg.apache.hadoop.fs.RemoteIterator;
  22. importorg.apache.hadoop.fs.UnsupportedFileSystemException;
  23. importorg.apache.hadoop.io.IOUtils;
  25. publicclassHiveSqlAnalyseTool{
  26. privateintthreadNum;
  27. privateStringdirType;
  28. privateStringjobHistoryPath;
  30. privateFileContextdoneDirFc;
  31. privatePathdoneDirPrefixPath;
  33. privateLinkedList<FileStatus>fileStatusList;
  34. privateHashMap<String,String[]>dataInfos;
  35. privateDbClientdbClient;
  37. publicHiveSqlAnalyseTool(StringdirType,StringjobHistoryPath,
  38. intthreadNum){
  39. this.threadNum=threadNum;
  40. this.dirType=dirType;
  41. this.jobHistoryPath=jobHistoryPath;
  43. this.dataInfos=newHashMap<String,String[]>();
  44. this.fileStatusList=newLinkedList<FileStatus>();
  45. this.dbClient=newDbClient(BaseValues.DB_URL,
  46. BaseValues.DB_USER_NAME,BaseValues.DB_PASSWORD,
  47. BaseValues.DB_HIVE_SQL_STAT_TABLE_NAME);
  49. try{
  50. doneDirPrefixPath=FileContext.getFileContext(newConfiguration())
  51. .makeQualified(newPath(this.jobHistoryPath));
  52. doneDirFc=FileContext.getFileContext(doneDirPrefixPath.toUri());
  53. }catch(UnsupportedFileSystemExceptione){
  54. //TODOAuto-generatedcatchblock
  55. e.printStackTrace();
  56. }catch(IllegalArgumentExceptione){
  57. //TODOAuto-generatedcatchblock
  58. e.printStackTrace();
  59. }
  60. }
  62. publicvoidreadJobInfoFiles(){
  63. List<FileStatus>files;
  65. files=newArrayList<FileStatus>();
  66. try{
  67. files=scanDirectory(doneDirPrefixPath,doneDirFc,files);
  68. }catch(IOExceptione){
  69. //TODOAuto-generatedcatchblock
  70. e.printStackTrace();
  71. }
  73. if(files!=null){
  74. for(FileStatusfs:files){
  75. //parseFileInfo(fs);
  76. }
  77. System.out.println("filesnumis"+files.size());
  78. System.out
  79. .println("fileStatusListsizeis"+fileStatusList.size());
  81. ParseThread[]threads;
  82. threads=newParseThread[threadNum];
  83. for(inti=0;i<threadNum;i++){
  84. System.out.println("thread"+i+"startrun");
  85. threads[i]=newParseThread(this,fileStatusList,dataInfos);
  86. threads[i].start();
  87. }
  89. for(inti=0;i<threadNum;i++){
  90. System.out.println("thread"+i+"joinrun");
  91. try{
  92. if(threads[i]!=null){
  93. threads[i].join();
  94. }
  95. }catch(InterruptedExceptione){
  96. //TODOAuto-generatedcatchblock
  97. e.printStackTrace();
  98. }
  99. }
  100. }else{
  101. System.out.println("filesisnull");
  102. }
  104. printStatDatas();
  105. }
  107. protectedList<FileStatus>scanDirectory(Pathpath,FileContextfc,
  108. List<FileStatus>jhStatusList)throwsIOException{
  109. path=fc.makeQualified(path);
  110. System.out.println("dirpathis"+path.getName());
  111. try{
  112. RemoteIterator<FileStatus>fileStatusIter=fc.listStatus(path);
  113. while(fileStatusIter.hasNext()){
  114. FileStatusfileStatus=fileStatusIter.next();
  115. PathfilePath=fileStatus.getPath();
  117. if(fileStatus.isFile()){
  118. jhStatusList.add(fileStatus);
  119. fileStatusList.add(fileStatus);
  120. }elseif(fileStatus.isDirectory()){
  121. scanDirectory(filePath,fc,jhStatusList);
  122. }
  123. }
  124. }catch(FileNotFoundExceptionfe){
  125. System.out.println("Errorwhilescanningdirectory"+path);
  126. }
  128. returnjhStatusList;
  129. }
  131. privatevoidparseFileInfo(FileStatusfs){
  132. StringresultStr;
  133. Stringstr;
  134. Stringusername;
  135. StringfileType;
  136. StringjobId;
  137. StringjobName;
  138. StringhiveSql;
  140. intstartPos;
  141. intendPos;
  142. inthiveSqlFlag;
  143. longlaunchTime;
  144. longfinishTime;
  145. intmapTaskNum;
  146. intreduceTaskNum;
  147. StringxmlNameFlag;
  148. StringlaunchTimeFlag;
  149. StringfinishTimeFlag;
  150. StringlaunchMapFlag;
  151. StringlaunchReduceFlag;
  153. Pathpath;
  154. FileSystemfileSystem;
  155. InputStreamin;
  157. resultStr="";
  158. fileType="";
  159. hiveSql="";
  160. jobId="";
  161. jobName="";
  162. username="";
  163. hiveSqlFlag=0;
  164. launchTime=0;
  165. finishTime=0;
  166. mapTaskNum=0;
  167. reduceTaskNum=0;
  168. xmlNameFlag="<value>";
  169. launchTimeFlag="\"launchTime\":";
  170. finishTimeFlag="\"finishTime\":";
  171. launchMapFlag="\"Launchedmaptasks\"";
  172. launchReduceFlag="\"Launchedreducetasks\"";
  174. path=fs.getPath();
  175. str=path.getName();
  176. if(str.endsWith(".xml")){
  177. fileType="config";
  179. endPos=str.lastIndexOf("_");
  180. jobId=str.substring(0,endPos);
  181. }elseif(str.endsWith(".jhist")){
  182. fileType="info";
  184. endPos=str.indexOf("-");
  185. jobId=str.substring(0,endPos);
  186. }else{
  187. return;
  188. }
  190. try{
  191. fileSystem=path.getFileSystem(newConfiguration());
  192. in=fileSystem.open(path);
  193. InputStreamReaderisr;
  194. BufferedReaderbr;
  196. isr=newInputStreamReader(in,"UTF-8");
  197. br=newBufferedReader(isr);
  199. while((str=br.readLine())!=null){
  200. if(str.contains("mapreduce.job.user.name")){
  201. startPos=str.indexOf(xmlNameFlag);
  202. endPos=str.indexOf("</value>");
  203. username=str.substring(startPos+xmlNameFlag.length(),
  204. endPos);
  205. }elseif(str.contains("mapreduce.job.name")){
  206. startPos=str.indexOf(xmlNameFlag);
  207. endPos=str.indexOf("</value>");
  208. jobName=str.substring(startPos+xmlNameFlag.length(),
  209. endPos);
  210. }elseif(str.contains("hive.query.string")){
  211. hiveSqlFlag=1;
  212. hiveSql=str;
  213. }elseif(hiveSqlFlag==1){
  214. hiveSql+=str;
  216. if(str.contains("</value>")){
  217. startPos=hiveSql.indexOf(xmlNameFlag);
  218. endPos=hiveSql.indexOf("</value>");
  219. hiveSql=hiveSql.substring(
  220. startPos+xmlNameFlag.length(),endPos);
  222. hiveSqlFlag=0;
  223. }
  224. }elseif(str.startsWith("{\"type\":\"JOB_INITED\"")){
  225. startPos=str.indexOf(launchTimeFlag);
  226. str=str.substring(startPos+launchTimeFlag.length());
  227. endPos=str.indexOf(",");
  228. launchTime=Long.parseLong(str.substring(0,endPos));
  229. }elseif(str.startsWith("{\"type\":\"JOB_FINISHED\"")){
  230. mapTaskNum=parseTaskNum(launchMapFlag,str);
  231. reduceTaskNum=parseTaskNum(launchReduceFlag,str);
  233. startPos=str.indexOf(finishTimeFlag);
  234. str=str.substring(startPos+finishTimeFlag.length());
  235. endPos=str.indexOf(",");
  236. finishTime=Long.parseLong(str.substring(0,endPos));
  237. }
  238. }
  240. System.out.println("jobIdis"+jobId);
  241. System.out.println("jobNameis"+jobName);
  242. System.out.println("usernameis"+username);
  243. System.out.println("maptasknumis"+mapTaskNum);
  244. System.out.println("reducetasknumis"+reduceTaskNum);
  245. System.out.println("launchTimeis"+launchTime);
  246. System.out.println("finishTimeis"+finishTime);
  247. System.out.println("hivequerysqlis"+hiveSql);
  248. }catch(IOExceptione){
  249. //TODOAuto-generatedcatchblock
  250. e.printStackTrace();
  251. }
  253. if(fileType.equals("config")){
  254. insertConfParseData(jobId,jobName,username,hiveSql);
  255. }elseif(fileType.equals("info")){
  256. insertJobInfoParseData(jobId,launchTime,finishTime,mapTaskNum,
  257. reduceTaskNum);
  258. }
  259. }
  261. privatevoidinsertConfParseData(StringjobId,StringjobName,
  262. Stringusername,Stringsql){
  263. String[]array;
  265. if(dataInfos.containsKey(jobId)){
  266. array=dataInfos.get(jobId);
  267. }else{
  268. array=newString[BaseValues.DB_COLUMN_HIVE_SQL_LEN];
  269. }
  271. array[BaseValues.DB_COLUMN_HIVE_SQL_JOBID]=jobId;
  272. array[BaseValues.DB_COLUMN_HIVE_SQL_JOBNAME]=jobName;
  273. array[BaseValues.DB_COLUMN_HIVE_SQL_USERNAME]=username;
  274. array[BaseValues.DB_COLUMN_HIVE_SQL_HIVE_SQL]=sql;
  276. dataInfos.put(jobId,array);
  277. }
  279. privatevoidinsertJobInfoParseData(StringjobId,longlaunchTime,
  280. longfinishedTime,intmapTaskNum,intreduceTaskNum){
  281. String[]array;
  283. if(dataInfos.containsKey(jobId)){
  284. array=dataInfos.get(jobId);
  285. }else{
  286. array=newString[BaseValues.DB_COLUMN_HIVE_SQL_LEN];
  287. }
  289. array[BaseValues.DB_COLUMN_HIVE_SQL_JOBID]=jobId;
  290. array[BaseValues.DB_COLUMN_HIVE_SQL_START_TIME]=String
  291. .valueOf(launchTime);
  292. array[BaseValues.DB_COLUMN_HIVE_SQL_FINISH_TIME]=String
  293. .valueOf(finishedTime);
  294. array[BaseValues.DB_COLUMN_HIVE_SQL_MAP_TASK_NUM]=String
  295. .valueOf(mapTaskNum);
  296. array[BaseValues.DB_COLUMN_HIVE_SQL_REDUCE_TASK_NUM]=String
  297. .valueOf(reduceTaskNum);
  299. dataInfos.put(jobId,array);
  300. }
  302. privateintparseTaskNum(Stringflag,StringjobStr){
  303. inttaskNum;
  304. intstartPos;
  305. intendPos;
  307. StringtmpStr;
  309. taskNum=0;
  310. tmpStr=jobStr;
  311. startPos=tmpStr.indexOf(flag);
  313. if(startPos==-1){
  314. return0;
  315. }
  317. tmpStr=tmpStr.substring(startPos+flag.length());
  318. endPos=tmpStr.indexOf("}");
  319. tmpStr=tmpStr.substring(0,endPos);
  320. taskNum=Integer.parseInt(tmpStr.split(":")[1]);
  322. returntaskNum;
  323. }
  325. privatevoidprintStatDatas(){
  326. StringjobId;
  327. StringjobInfo;
  328. String[]infos;
  330. if(dbClient!=null){
  331. dbClient.createConnection();
  332. }
  334. if(dataInfos!=null){
  335. System.out.println("mapdatasizeis"+dataInfos.size());
  337. if(dbClient!=null&&dirType.equals("dateTimeDir")){
  338. dbClient.insertDataBatch(dataInfos);
  339. }
  340. }
  342. /*for(Entry<String,String[]>entry:this.dataInfos.entrySet()){
  343. jobId=entry.getKey();
  344. infos=entry.getValue();
  346. jobInfo=String
  347. .format("jobIdis%s,jobName:%s,usrname:%s,launchTime:%s,finishTime:%s,mapTaskNum:%s,reduceTaskNum:%s,querySql:%s",
  348. jobId,infos[1],infos[2],infos[3],infos[4],
  349. infos[5],infos[6],infos[7]);
  350. //System.out.println("jobdetailinfo"+jobInfo);
  352. if(dbClient!=null&&dirType.equals("dateTimeDir")){
  353. dbClient.insertHiveSqlStatData(infos);
  354. }
  355. }*/
  357. if(dbClient!=null){
  358. dbClient.closeConnection();
  359. }
  360. }
  362. publicsynchronizedFileStatusgetOneFile(){
  363. FileStatusfs;
  365. fs=null;
  366. if(fileStatusList!=null&fileStatusList.size()>0){
  367. fs=fileStatusList.poll();
  368. }
  370. returnfs;
  371. }
  373. publicsynchronizedvoidaddDataToMap(StringjobId,String[]values){
  374. if(dataInfos!=null){
  375. dataInfos.put(jobId,values);
  376. }
  377. }
  378. }

解析线程代码ParseThread.java:

[java] view plain copy print ?
  1. packageorg.apache.hadoop.mapreduce.v2.hs.tool.sqlanalyse;
  3. importjava.io.BufferedReader;
  4. importjava.io.IOException;
  5. importjava.io.InputStream;
  6. importjava.io.InputStreamReader;
  7. importjava.util.HashMap;
  8. importjava.util.LinkedList;
  10. importorg.apache.hadoop.conf.Configuration;
  11. importorg.apache.hadoop.fs.FileStatus;
  12. importorg.apache.hadoop.fs.FileSystem;
  13. importorg.apache.hadoop.fs.Path;
  15. publicclassParseThreadextendsThread{
  16. privateHiveSqlAnalyseTooltool;
  17. privateLinkedList<FileStatus>fileStatus;
  18. privateHashMap<String,String[]>dataInfos;
  20. publicParseThread(HiveSqlAnalyseTooltool,LinkedList<FileStatus>fileStatus,HashMap<String,String[]>dataInfos){
  21. this.tool=tool;
  22. this.fileStatus=fileStatus;
  23. this.dataInfos=dataInfos;
  24. }
  26. @Override
  27. publicvoidrun(){
  28. FileStatusfs;
  30. while(fileStatus!=null&&!fileStatus.isEmpty()){
  31. fs=tool.getOneFile();
  32. parseFileInfo(fs);
  33. }
  35. super.run();
  36. }
  38. privatevoidparseFileInfo(FileStatusfs){
  39. Stringstr;
  40. Stringusername;
  41. StringfileType;
  42. StringjobId;
  43. StringjobName;
  44. StringhiveSql;
  46. intstartPos;
  47. intendPos;
  48. inthiveSqlFlag;
  49. longlaunchTime;
  50. longfinishTime;
  51. intmapTaskNum;
  52. intreduceTaskNum;
  53. StringxmlNameFlag;
  54. StringlaunchTimeFlag;
  55. StringfinishTimeFlag;
  56. StringlaunchMapFlag;
  57. StringlaunchReduceFlag;
  59. Pathpath;
  60. FileSystemfileSystem;
  61. InputStreamin;
  63. fileType="";
  64. hiveSql="";
  65. jobId="";
  66. jobName="";
  67. username="";
  68. hiveSqlFlag=0;
  69. launchTime=0;
  70. finishTime=0;
  71. mapTaskNum=0;
  72. reduceTaskNum=0;
  73. xmlNameFlag="<value>";
  74. launchTimeFlag="\"launchTime\":";
  75. finishTimeFlag="\"finishTime\":";
  76. launchMapFlag="\"Launchedmaptasks\"";
  77. launchReduceFlag="\"Launchedreducetasks\"";
  79. path=fs.getPath();
  80. str=path.getName();
  81. if(str.endsWith(".xml")){
  82. fileType="config";
  84. endPos=str.lastIndexOf("_");
  85. jobId=str.substring(0,endPos);
  86. }elseif(str.endsWith(".jhist")){
  87. fileType="info";
  89. endPos=str.indexOf("-");
  90. jobId=str.substring(0,endPos);
  91. }else{
  92. return;
  93. }
  95. try{
  96. fileSystem=path.getFileSystem(newConfiguration());
  97. in=fileSystem.open(path);
  98. InputStreamReaderisr;
  99. BufferedReaderbr;
  101. isr=newInputStreamReader(in,"UTF-8");
  102. br=newBufferedReader(isr);
  104. while((str=br.readLine())!=null){
  105. if(str.contains("mapreduce.job.user.name")){
  106. startPos=str.indexOf(xmlNameFlag);
  107. endPos=str.indexOf("</value>");
  108. username=str.substring(startPos+xmlNameFlag.length(),
  109. endPos);
  110. }elseif(str.contains("mapreduce.job.name")){
  111. startPos=str.indexOf(xmlNameFlag);
  112. endPos=str.indexOf("</value>");
  113. jobName=str.substring(startPos+xmlNameFlag.length(),
  114. endPos);
  115. }elseif(str.contains("hive.query.string")){
  116. hiveSqlFlag=1;
  118. hiveSql=str;
  119. }elseif(hiveSqlFlag==1){
  120. hiveSql+=str;
  122. if(str.contains("</value>")){
  123. startPos=hiveSql.indexOf(xmlNameFlag);
  124. endPos=hiveSql.indexOf("</value>");
  125. hiveSql=hiveSql.substring(
  126. startPos+xmlNameFlag.length(),endPos);
  128. hiveSqlFlag=0;
  129. }
  130. }elseif(str.startsWith("{\"type\":\"JOB_INITED\"")){
  131. startPos=str.indexOf(launchTimeFlag);
  132. str=str.substring(startPos+launchTimeFlag.length());
  133. endPos=str.indexOf(",");
  134. launchTime=Long.parseLong(str.substring(0,endPos));
  135. }elseif(str.startsWith("{\"type\":\"JOB_FINISHED\"")){
  136. mapTaskNum=parseTaskNum(launchMapFlag,str);
  137. reduceTaskNum=parseTaskNum(launchReduceFlag,str);
  139. startPos=str.indexOf(finishTimeFlag);
  140. str=str.substring(startPos+finishTimeFlag.length());
  141. endPos=str.indexOf(",");
  142. finishTime=Long.parseLong(str.substring(0,endPos));
  143. }
  144. }
  146. /*System.out.println("jobIdis"+jobId);
  147. System.out.println("jobNameis"+jobName);
  148. System.out.println("usernameis"+username);
  149. System.out.println("maptasknumis"+mapTaskNum);
  150. System.out.println("reducetasknumis"+reduceTaskNum);
  151. System.out.println("launchTimeis"+launchTime);
  152. System.out.println("finishTimeis"+finishTime);
  153. System.out.println("hivequerysqlis"+hiveSql);*/
  154. }catch(IOExceptione){
  155. //TODOAuto-generatedcatchblock
  156. e.printStackTrace();
  157. }
  159. if(fileType.equals("config")){
  160. insertConfParseData(jobId,jobName,username,hiveSql);
  161. }elseif(fileType.equals("info")){
  162. insertJobInfoParseData(jobId,launchTime,finishTime,mapTaskNum,
  163. reduceTaskNum);
  164. }
  165. }
  167. privatevoidinsertConfParseData(StringjobId,StringjobName,
  168. Stringusername,Stringsql){
  169. String[]array;
  171. if(dataInfos.containsKey(jobId)){
  172. array=dataInfos.get(jobId);
  173. }else{
  174. array=newString[BaseValues.DB_COLUMN_HIVE_SQL_LEN];
  175. }
  177. array[BaseValues.DB_COLUMN_HIVE_SQL_JOBID]=jobId;
  178. array[BaseValues.DB_COLUMN_HIVE_SQL_JOBNAME]=jobName;
  179. array[BaseValues.DB_COLUMN_HIVE_SQL_USERNAME]=username;
  180. array[BaseValues.DB_COLUMN_HIVE_SQL_HIVE_SQL]=sql;
  182. tool.addDataToMap(jobId,array);
  183. }
  185. privatevoidinsertJobInfoParseData(StringjobId,longlaunchTime,
  186. longfinishedTime,intmapTaskNum,intreduceTaskNum){
  187. String[]array;
  189. if(dataInfos.containsKey(jobId)){
  190. array=dataInfos.get(jobId);
  191. }else{
  192. array=newString[BaseValues.DB_COLUMN_HIVE_SQL_LEN];
  193. }
  195. array[BaseValues.DB_COLUMN_HIVE_SQL_JOBID]=jobId;
  196. array[BaseValues.DB_COLUMN_HIVE_SQL_START_TIME]=String
  197. .valueOf(launchTime);
  198. array[BaseValues.DB_COLUMN_HIVE_SQL_FINISH_TIME]=String
  199. .valueOf(finishedTime);
  200. array[BaseValues.DB_COLUMN_HIVE_SQL_MAP_TASK_NUM]=String
  201. .valueOf(mapTaskNum);
  202. array[BaseValues.DB_COLUMN_HIVE_SQL_REDUCE_TASK_NUM]=String
  203. .valueOf(reduceTaskNum);
  205. tool.addDataToMap(jobId,array);
  206. }
  208. privateintparseTaskNum(Stringflag,StringjobStr){
  209. inttaskNum;
  210. intstartPos;
  211. intendPos;
  213. StringtmpStr;
  215. taskNum=0;
  216. tmpStr=jobStr;
  217. startPos=tmpStr.indexOf(flag);
  219. if(startPos==-1){
  220. return0;
  221. }
  223. tmpStr=tmpStr.substring(startPos+flag.length());
  224. endPos=tmpStr.indexOf("}");
  225. tmpStr=tmpStr.substring(0,endPos);
  226. taskNum=Integer.parseInt(tmpStr.split(":")[1]);
  228. returntaskNum;
  229. }
  230. }


其他更多Yarn,Hadoop方面代码的分析请点击链接 https://github.com/linyiqun/hadoop-yarn ,后续将会继续更新YARN其他方面的代码分析。
小飞侠-2
关注
数仓工具—Hive源码之SQL解析Antlr进阶(8)
08-30 4万+
我们这里总结一下使用Antlr 的一个流程步骤基于需求按照ANTLR4的规则编写自定义语法的语义规则, 保存成以g4为后缀的文件。使用ANTLR4工具处理g4文件，生成词法分析器、句法分析器代码、词典文件。编写代码继承Visitor类或实现Listener接口，开发自己的业务逻辑代码。其实我们看到最重要的就是实现Visitor接口，因为我们的逻辑在里面Listener模式通过walker对象自行遍历，不用考虑其语法树上下级关系。......
hive sql解析
08-15
hivesql解析 支持版本<!--1.0.0 2.4.1 --> 2.0.1 2.7.2
HiveSqlBloodFigure:hive血缘关系解析工具
04-18
HiveSqlBloodFigure 如果你喜欢这个项目，那就点击一下右上方的【Star】以及【Fork】，支持一下我，让我有动力持续更新！ 项目介绍 在数据仓库建设中，经常会使用到数据血缘追中方面的功能，本项目实现了对hql集合进行静态分析，获取hql对应的血缘图（表血缘 + 字段血缘） 项目升级内容 删除hive-exec与hadoop-common的maven依赖，使得项目更加的轻量级。 重构项目代码，优化解析，修复无字段血缘时，不能获取表血缘的BUG。 规范化接口输入输出，血缘图均为自定义实体，方便进行JSON序列化。 新增接口层，方便Spring的注入，同时也提供静态方式调用。 下个版本升级内容 引入JDBC获取元数据信息，使血缘图更加丰富，同时可以解决Sql中有select * 的问题。 测试用例 请关注test下的HiveBloodEngineTest与HiveSqlBloo
[工具类] Hive SQL
weixin_33825683的博客
11-24 136
package com.claw.util.hive; import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.List; public class Hql { public static S...
大数据分析工具——hive入门
大数据Hive教程
01-06 539
Hive ** Facebook开源 ** 官网：hive.apache.org ** Hive是基于Hadoop的一个数据仓库工具 Hive与数据库： 数据库: mysql、oracle、DB2、sqlserver 数据仓库 !== 数据库 换言之, Hive不是数据库 为什么要选择hive ** MapReduce编程成本高 ** 针对传统的DBA,不会不熟悉java,要想数...
Hive SQL
weixin_45922185的博客
11-12 1621
DDL 表结构 表的创建 创建表 create database if not exists myhive; create database myhive2 location '/myhive2';//指定hdfs存储位置 查看数据库详细信息 desc database myhive2; hive (myhive)> desc database extended myhive2; 删除数据库 drop database myhive2; 创建表 create table
Hive SQL迁移Spark SQL在滴滴的实践
DiDi_Tech的博客
01-25 1564
桔妹导读：在滴滴SQL任务从Hive迁移到Spark后，Spark SQL任务占比提升至85%，任务运行时间节省40%，运行任务需要的计算资源节省21%，内存资源节省49%。在迁移过程中...
hive插入多条数据sql_hive sql语法
weixin_39808726的博客
12-21 4948
show tables like '*name*';2.查看表结构信息desc formatted table_name;desc table_name;3.查看分区信息show partitions table_name;4.根据分区查询数据select table_coulm from table_name where partition_name = '2014-02-25';5.查看hdf...
Hive SQL操作与函数自定义（一）
梓纾的专栏
09-21 1万+
Hive SQl操作简介；关于UDF、UDAF、UDTF的自定义；以及其他一些整理资料（例如自定义函数jar包的放在那里，远程调试等）
hive parser工具类
02-07
hive sql 解析工具类,传入sql(支持多段sql,以";"隔开),返回map 获取表get("tables")获取sql语句 get("sqls")
HiveSQL详细和优化
08-05
HiveSQL详细和优化，以及部分个人点评 This is a brief tutorial that provides an introduction on how to use Apache Hive HiveQL with Hadoop Distributed File System. This tutorial can be your first step towards becoming a successful Hadoop Developer with Hive.
SQL、Hive SQL等SQL血缘解析工具
01-14
// 测试用例如下 // 设置元数据服务 Delegate.getDelegate().setMetaColumnService(new IMetaColumnService() { @Override public List<String> queryMetaColumn(String dbName, String tableName) { return Collections.emptyList(); } @Override public boolean clearMetaColumnCache() { return true; } }); // 设置通知服务 Delegate.getDelegate().setNoticeService(s->{}); // 具有子查询的sql String hql = "select id,name from (select id from table_1 where id={p0}) t1 inner join (select name --this is name\n from table_2) t2"; // 获取id字段的血缘 LineageNode idNode = Delegate.getDelegate().getLineage(hql, "id"); // 获取name字段的血缘 LineageNode nameNode = Delegate.getDelegate().getLineage(hql, "name"); // 打印血缘 Utils.printLineage(idNode,nameNode);
不care工具，在大数据平台中Hive能自动处理SQL
频道新闻
04-19 138
本文分享自华为云社区《Hive执行原理》，作者： JavaEdge 。 MapReduce简化了大数据编程的难度，使得大数据计算不再是高不可攀的技术圣殿，普通工程师也能使用MapReduce开发大数据程序。但是对于经常需要进行大数据计算的人，比如从事研究商业智能（BI）的数据分析师来说，他们通常使用SQL进行大数据分析和统计，MapReduce编程还是有一定的门槛。而且如果每次统计和分析都开发相应的MapReduce程序，成本也确实太高了。 有没有更简单的办法，可以直接将SQL运行在大数据平台？ 先看
JAVA解析sql表别名_hive中sql解析出对应表和字段的实现
weixin_31207903的博客
02-25 2229
import java.io.IOException;import java.util.HashMap;import java.util.HashSet;import java.util.Map;import java.util.Set;import java.util.Stack;import java.util.TreeMap;import org.apache.hadoop.hive.ql....
hive 优化 tips
学无止境
10-17 5114
一、     Hive join优化 1.     尽量将小表放在join的左边，我们使用的Hive-0.90,所以是自动转化的，既把小表自动装入内存，执行map side join(性能好), 这是由参数hive.auto.convert.join=true 和hive.smalltable.filesize=25000000L）参数控制（默认是25M），如果表文件大小在25M左右，可以适当调
Hive on Mr Job重复执行问题排查
热门推荐
u013332124的专栏
06-05 3万+
文章目录一、问题描述二、问题排查进度三、Hive执行任务的具体逻辑3.1、Hive源码解析3.2、生成重复job问题分析四、问题总结和代码修复 一、问题描述 业务反馈某张表的落地数据总大小比平时多了一倍。 平时正常落地6-7G，而这次落地的数据量有14G。后该任务重跑后数据恢复正常： 表落地数据使用的相关sql如下(为了不暴露公司相关业务信息，只展示sql的主体结构)： set mapreduce.job.queuename=xxxxx; insert overwrite table xxxxxxxx
hadoop job 数量_[一起学Hive]之十九-使用Hive API分析HQL的执行计划、Job数量和表的血缘关系...
weixin_31750655的博客
12-29 399
关键字：Hive HQL Job数量、Hive执行计划、Hive LineageInfo本文介绍使用Hive的API获取一条HQL的最终执行计划，从而获取这条HQL的Job数量，另外，介绍使用API分析一条HQL中所包含的输入表和输出表。这些信息在做元数据管理和Hive表的血缘分析时候很有用。Hive在执行一条HQL的时候，会经过以下步骤：语法解析：Antlr定义SQL的语法规则，完成SQL词法，...
记录一次解决问题思路，解析Hivesql的工具
qq_41565349的博客
10-27 663
记录一次解决问题思路，解析Hivesql的工具 一、背景： 有两个建表语句的HiveSql 1.一个是创建Hive表时使用的HiveSql，当然包含partion CREATE EXTERNAL TABLE IF NOT EXISTS s.ao (\n" + “\tdate String COMMENT ‘日期’,\n” + “\tisManaged boolean COMMENT ‘是否代管’,\n” + “\tisLocal boolean COMMENT ‘是否本地’\n” + “\t\n” +
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值