PageRenderTime 58ms CodeModel.GetById 18ms RepoModel.GetById 1ms app.codeStats 0ms

/site/publish/docs/r0.11.1/perf.html

#
HTML | 1429 lines | 1226 code | 122 blank | 81 comment | 0 complexity | 3754579a554a65c83ec47285d3c70b6a MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    2. 

  2. <html>
    3. 

  3. <head>
    4. 

  4. <META http-equiv="Content-Type" content="text/html; charset=UTF-8">
    5. 

  5. <meta content="Apache Forrest" name="Generator">
    6. 

  6. <meta name="Forrest-version" content="0.9">
    7. 

  7. <meta name="Forrest-skin-name" content="pelt">
    8. 

  8. <title>Performance and Efficiency</title>
    9. 

  9. <link type="text/css" href="skin/basic.css" rel="stylesheet">
    10. 

  10. <link media="screen" type="text/css" href="skin/screen.css" rel="stylesheet">
    11. 

  11. <link media="print" type="text/css" href="skin/print.css" rel="stylesheet">
    12. 

  12. <link type="text/css" href="skin/profile.css" rel="stylesheet">
    13. 

  13. <script src="skin/getBlank.js" language="javascript" type="text/javascript"></script><script src="skin/getMenu.js" language="javascript" type="text/javascript"></script><script src="skin/fontsize.js" language="javascript" type="text/javascript"></script>
    14. 

  14. <link rel="shortcut icon" href="">
    15. 

  15. </head>
    16. 

  16. <body onload="init()">
    17. 

  17. <script type="text/javascript">ndeSetTextSize();</script>
    18. 

  18. <div id="top">
    19. 

  19. <!--+
    20. 

  20.     |breadtrail
    21. 

  21.     +-->
    22. 

  22. <div class="breadtrail">
    23. 

  23. <a href="http://www.apache.org/">Apache</a> &gt; <a href="http://hadoop.apache.org/">Hadoop</a> &gt; <a href="http://hadoop.apache.org/pig/">Pig</a><script src="skin/breadcrumbs.js" language="JavaScript" type="text/javascript"></script>
    24. 

  24. </div>
    25. 

  25. <!--+
    26. 

  26.     |header
    27. 

  27.     +-->
    28. 

  28. <div class="header">
    29. 

  29. <!--+
    30. 

  30.     |start group logo
    31. 

  31.     +-->
    32. 

  32. <div class="grouplogo">
    33. 

  33. <a href="http://hadoop.apache.org/"><img class="logoImage" alt="Hadoop" src="images/hadoop-logo.jpg" title="Apache Hadoop"></a>
    34. 

  34. </div>
    35. 

  35. <!--+
    36. 

  36.     |end group logo
    37. 

  37.     +-->
    38. 

  38. <!--+
    39. 

  39.     |start Project Logo
    40. 

  40.     +-->
    41. 

  41. <div class="projectlogo">
    42. 

  42. <a href="http://hadoop.apache.org/pig/"><img class="logoImage" alt="Pig" src="images/pig-logo.gif" title="A platform for analyzing large datasets."></a>
    43. 

  43. </div>
    44. 

  44. <!--+
    45. 

  45.     |end Project Logo
    46. 

  46.     +-->
    47. 

  47. <!--+
    48. 

  48.     |start Search
    49. 

  49.     +-->
    50. 

  50. <div class="searchbox">
    51. 

  51. <form action="http://www.google.com/search" method="get" class="roundtopsmall">
    52. 

  52. <input value="" name="sitesearch" type="hidden"><input onFocus="getBlank (this, 'Search the site with google');" size="25" name="q" id="query" type="text" value="Search the site with google">&nbsp; 
    53. 

  53.                     <input name="Search" value="Search" type="submit">
    54. 

  54. </form>
    55. 

  55. </div>
    56. 

  56. <!--+
    57. 

  57.     |end search
    58. 

  58.     +-->
    59. 

  59. <!--+
    60. 

  60.     |start Tabs
    61. 

  61.     +-->
    62. 

  62. <ul id="tabs">
    63. 

  63. <li>
    64. 

  64. <a class="unselected" href="http://hadoop.apache.org/pig/">Project</a>
    65. 

  65. </li>
    66. 

  66. <li>
    67. 

  67. <a class="unselected" href="http://wiki.apache.org/pig/">Wiki</a>
    68. 

  68. </li>
    69. 

  69. <li class="current">
    70. 

  70. <a class="selected" href="index.html">Pig 0.11.1 Documentation</a>
    71. 

  71. </li>
    72. 

  72. </ul>
    73. 

  73. <!--+
    74. 

  74.     |end Tabs
    75. 

  75.     +-->
    76. 

  76. </div>
    77. 

  77. </div>
    78. 

  78. <div id="main">
    79. 

  79. <div id="publishedStrip">
    80. 

  80. <!--+
    81. 

  81.     |start Subtabs
    82. 

  82.     +-->
    83. 

  83. <div id="level2tabs"></div>
    84. 

  84. <!--+
    85. 

  85.     |end Endtabs
    86. 

  86.     +-->
    87. 

  87. <script type="text/javascript"><!--
    88. 

  88. document.write("Last Published: " + document.lastModified);
    89. 

  89. //  --></script>
    90. 

  90. </div>
    91. 

  91. <!--+
    92. 

  92.     |breadtrail
    93. 

  93.     +-->
    94. 

  94. <div class="breadtrail">
    95. 

  95. 

  96.              &nbsp;
    97. 

  97.            </div>
    98. 

  98. <!--+
    99. 

  99.     |start Menu, mainarea
    100. 

  100.     +-->
    101. 

  101. <!--+
    102. 

  102.     |start Menu
    103. 

  103.     +-->
    104. 

  104. <div id="menu">
    105. 

  105. <div onclick="SwitchMenu('menu_selected_1.1', 'skin/')" id="menu_selected_1.1Title" class="menutitle" style="background-image: url('skin/images/chapter_open.gif');">Pig</div>
    106. 

  106. <div id="menu_selected_1.1" class="selectedmenuitemgroup" style="display: block;">
    107. 

  107. <div class="menuitem">
    108. 

  108. <a href="index.html">Overview</a>
    109. 

  109. </div>
    110. 

  110. <div class="menuitem">
    111. 

  111. <a href="start.html">Getting Started</a>
    112. 

  112. </div>
    113. 

  113. <div class="menuitem">
    114. 

  114. <a href="basic.html">Pig Latin Basics</a>
    115. 

  115. </div>
    116. 

  116. <div class="menuitem">
    117. 

  117. <a href="func.html">Built In Functions</a>
    118. 

  118. </div>
    119. 

  119. <div class="menuitem">
    120. 

  120. <a href="udf.html">User Defined Functions</a>
    121. 

  121. </div>
    122. 

  122. <div class="menuitem">
    123. 

  123. <a href="cont.html">Control Structures</a>
    124. 

  124. </div>
    125. 

  125. <div class="menuitem">
    126. 

  126. <a href="cmds.html">Shell and Utililty Commands</a>
    127. 

  127. </div>
    128. 

  128. <div class="menupage">
    129. 

  129. <div class="menupagetitle">Performance and Efficiency</div>
    130. 

  130. </div>
    131. 

  131. <div class="menuitem">
    132. 

  132. <a href="test.html">Testing and Diagnostics</a>
    133. 

  133. </div>
    134. 

  134. <div class="menuitem">
    135. 

  135. <a href="pig-index.html">Index</a>
    136. 

  136. </div>
    137. 

  137. </div>
    138. 

  138. <div onclick="SwitchMenu('menu_1.2', 'skin/')" id="menu_1.2Title" class="menutitle">Miscellaneous</div>
    139. 

  139. <div id="menu_1.2" class="menuitemgroup">
    140. 

  140. <div class="menuitem">
    141. 

  141. <a href="api/">API Docs</a>
    142. 

  142. </div>
    143. 

  143. <div class="menuitem">
    144. 

  144. <a href="jdiff/changes.html">API Changes</a>
    145. 

  145. </div>
    146. 

  146. <div class="menuitem">
    147. 

  147. <a href="https://cwiki.apache.org/confluence/display/PIG">Wiki</a>
    148. 

  148. </div>
    149. 

  149. <div class="menuitem">
    150. 

  150. <a href="https://cwiki.apache.org/confluence/display/PIG/FAQ">FAQ</a>
    151. 

  151. </div>
    152. 

  152. <div class="menuitem">
    153. 

  153. <a href="http://hadoop.apache.org/pig/releases.html">Release Notes</a>
    154. 

  154. </div>
    155. 

  155. </div>
    156. 

  156. <div id="credit"></div>
    157. 

  157. <div id="roundbottom">
    158. 

  158. <img style="display: none" class="corner" height="15" width="15" alt="" src="skin/images/rc-b-l-15-1body-2menu-3menu.png"></div>
    159. 

  159. <!--+
    160. 

  160.   |alternative credits
    161. 

  161.   +-->
    162. 

  162. <div id="credit2"></div>
    163. 

  163. </div>
    164. 

  164. <!--+
    165. 

  165.     |end Menu
    166. 

  166.     +-->
    167. 

  167. <!--+
    168. 

  168.     |start content
    169. 

  169.     +-->
    170. 

  170. <div id="content">
    171. 

  171. <div title="Portable Document Format" class="pdflink">
    172. 

  172. <a class="dida" href="perf.pdf"><img alt="PDF -icon" src="skin/images/pdfdoc.gif" class="skin"><br>
    173. 

  173.         PDF</a>
    174. 

  174. </div>
    175. 

  175. <h1>Performance and Efficiency</h1>
    176. 

  176. <div id="front-matter">
    177. 

  177. <div id="minitoc-area">
    178. 

  178. <ul class="minitoc">
    179. 

  179. <li>
    180. 

  180. <a href="#profiling">Timing your UDFs</a>
    181. 

  181. </li>
    182. 

  182. <li>
    183. 

  183. <a href="#combiner">Combiner</a>
    184. 

  184. <ul class="minitoc">
    185. 

  185. <li>
    186. 

  186. <a href="#When+the+Combiner+is+Used">When the Combiner is Used</a>
    187. 

  187. </li>
    188. 

  188. <li>
    189. 

  189. <a href="#When+the+Combiner+is+Not+Used">When the Combiner is Not Used</a>
    190. 

  190. </li>
    191. 

  191. </ul>
    192. 

  192. </li>
    193. 

  193. <li>
    194. 

  194. <a href="#hash-based-aggregation">Hash-based Aggregation in Map Task</a>
    195. 

  195. </li>
    196. 

  196. <li>
    197. 

  197. <a href="#memory-management">Memory Management</a>
    198. 

  198. </li>
    199. 

  199. <li>
    200. 

  200. <a href="#reducer-estimation">Reducer Estimation</a>
    201. 

  201. </li>
    202. 

  202. <li>
    203. 

  203. <a href="#multi-query-execution">Multi-Query Execution</a>
    204. 

  204. <ul class="minitoc">
    205. 

  205. <li>
    206. 

  206. <a href="#Turning+it+On+or+Off">Turning it On or Off</a>
    207. 

  207. </li>
    208. 

  208. <li>
    209. 

  209. <a href="#How+it+Works">How it Works</a>
    210. 

  210. </li>
    211. 

  211. <li>
    212. 

  212. <a href="#store-dump">Store vs. Dump</a>
    213. 

  213. </li>
    214. 

  214. <li>
    215. 

  215. <a href="#error-handling">Error Handling</a>
    216. 

  216. </li>
    217. 

  217. <li>
    218. 

  218. <a href="#backward-compatibility">Backward Compatibility</a>
    219. 

  219. </li>
    220. 

  220. <li>
    221. 

  221. <a href="#Implicit-Dependencies">Implicit Dependencies</a>
    222. 

  222. </li>
    223. 

  223. </ul>
    224. 

  224. </li>
    225. 

  225. <li>
    226. 

  226. <a href="#optimization-rules">Optimization Rules</a>
    227. 

  227. <ul class="minitoc">
    228. 

  228. <li>
    229. 

  229. <a href="#FilterLogicExpressionSimplifier">FilterLogicExpressionSimplifier</a>
    230. 

  230. </li>
    231. 

  231. <li>
    232. 

  232. <a href="#SplitFilter">SplitFilter</a>
    233. 

  233. </li>
    234. 

  234. <li>
    235. 

  235. <a href="#PushUpFilter">PushUpFilter</a>
    236. 

  236. </li>
    237. 

  237. <li>
    238. 

  238. <a href="#MergeFilter">MergeFilter</a>
    239. 

  239. </li>
    240. 

  240. <li>
    241. 

  241. <a href="#PushDownForEachFlatten">PushDownForEachFlatten</a>
    242. 

  242. </li>
    243. 

  243. <li>
    244. 

  244. <a href="#LimitOptimizer">LimitOptimizer</a>
    245. 

  245. </li>
    246. 

  246. <li>
    247. 

  247. <a href="#ColumnMapKeyPrune">ColumnMapKeyPrune</a>
    248. 

  248. </li>
    249. 

  249. <li>
    250. 

  250. <a href="#AddForEach">AddForEach</a>
    251. 

  251. </li>
    252. 

  252. <li>
    253. 

  253. <a href="#MergeForEach">MergeForEach</a>
    254. 

  254. </li>
    255. 

  255. <li>
    256. 

  256. <a href="#GroupByConstParallelSetter">GroupByConstParallelSetter</a>
    257. 

  257. </li>
    258. 

  258. </ul>
    259. 

  259. </li>
    260. 

  260. <li>
    261. 

  261. <a href="#performance-enhancers">Performance Enhancers</a>
    262. 

  262. <ul class="minitoc">
    263. 

  263. <li>
    264. 

  264. <a href="#Use+Optimization">Use Optimization</a>
    265. 

  265. </li>
    266. 

  266. <li>
    267. 

  267. <a href="#types">Use Types</a>
    268. 

  268. </li>
    269. 

  269. <li>
    270. 

  270. <a href="#projection">Project Early and Often </a>
    271. 

  271. </li>
    272. 

  272. <li>
    273. 

  273. <a href="#filter">Filter Early and Often</a>
    274. 

  274. </li>
    275. 

  275. <li>
    276. 

  276. <a href="#pipeline">Reduce Your Operator Pipeline</a>
    277. 

  277. </li>
    278. 

  278. <li>
    279. 

  279. <a href="#algebraic-interface">Make Your UDFs Algebraic</a>
    280. 

  280. </li>
    281. 

  281. <li>
    282. 

  282. <a href="#accumulator-interface">Use the Accumulator Interface</a>
    283. 

  283. </li>
    284. 

  284. <li>
    285. 

  285. <a href="#nulls">Drop Nulls Before a Join</a>
    286. 

  286. </li>
    287. 

  287. <li>
    288. 

  288. <a href="#join-optimizations">Take Advantage of Join Optimizations</a>
    289. 

  289. </li>
    290. 

  290. <li>
    291. 

  291. <a href="#parallel">Use the Parallel Features</a>
    292. 

  292. </li>
    293. 

  293. <li>
    294. 

  294. <a href="#limit">Use the LIMIT Operator</a>
    295. 

  295. </li>
    296. 

  296. <li>
    297. 

  297. <a href="#distinct">Prefer DISTINCT over GROUP BY/GENERATE</a>
    298. 

  298. </li>
    299. 

  299. <li>
    300. 

  300. <a href="#compression">Compress the Results of Intermediate Jobs</a>
    301. 

  301. </li>
    302. 

  302. <li>
    303. 

  303. <a href="#combine-files">Combine Small Input Files</a>
    304. 

  304. </li>
    305. 

  305. </ul>
    306. 

  306. </li>
    307. 

  307. <li>
    308. 

  308. <a href="#specialized-joins">Specialized Joins</a>
    309. 

  309. <ul class="minitoc">
    310. 

  310. <li>
    311. 

  311. <a href="#replicated-joins">Replicated Joins</a>
    312. 

  312. </li>
    313. 

  313. <li>
    314. 

  314. <a href="#skewed-joins">Skewed Joins</a>
    315. 

  315. </li>
    316. 

  316. <li>
    317. 

  317. <a href="#merge-joins">Merge Joins</a>
    318. 

  318. </li>
    319. 

  319. <li>
    320. 

  320. <a href="#merge-sparse-joins">Merge-Sparse Joins</a>
    321. 

  321. </li>
    322. 

  322. <li>
    323. 

  323. <a href="#specialized-joins-performance">Performance Considerations</a>
    324. 

  324. </li>
    325. 

  325. </ul>
    326. 

  326. </li>
    327. 

  327. </ul>
    328. 

  328. </div>
    329. 

  329. </div> 
    330. 

  330.   
    331. 

  331. 

  332. <a name="profiling"></a>
    333. 

  333. <h2 class="h3">Timing your UDFs</h2>
    334. 

  334. <div class="section">
    335. 

  335. <p>The first step to improving performance and efficiency is measuring where the time is going. Pig provides a light-weight method for approximately measuring how much time is spent in different user-defined functions (UDFs) and Loaders. Simply set the pig.udf.profile property to true. This will cause new counters to be tracked for all Map-Reduce jobs generated by your script: approx_microsecs measures the approximate amount of time spent in a UDF, and approx_invocations measures the approximate number of times the UDF was invoked. Note that this may produce a large number of counters (two per UDF). Excessive amounts of counters can lead to poor JobTracker performance, so use this feature carefully, and preferably on a test cluster.</p>
    336. 

  336. </div>
    337. 

  337. 

  338. <!-- ================================================================== -->
    339. 

  339. <!-- COMBINER -->
    340. 

  340. 

  341. <a name="combiner"></a>
    342. 

  342. <h2 class="h3">Combiner</h2>
    343. 

  343. <div class="section">
    344. 

  344. <p>The Pig combiner is an optimizer that is invoked when the statements in your scripts are arranged in certain ways. The examples below demonstrate when the combiner is used and not used. Whenever possible, make sure the combiner is used as it frequently yields an order of magnitude improvement in performance. </p>
    345. 

  345. <a name="When+the+Combiner+is+Used"></a>
    346. 

  346. <h3 class="h4">When the Combiner is Used</h3>
    347. 

  347. <p>The combiner is generally used in the case of non-nested foreach where all projections are either expressions on the group column or expressions on algebraic UDFs (see  <a href="#Algebraic-interface">Make Your UDFs Algebraic</a>).</p>
    348. 

  348. <p>Example:</p>
    349. 

  349. <pre class="code">
    350. 

  350. A = load 'studenttab10k' as (name, age, gpa);
    351. 

  351. B = group A by age;
    352. 

  352. C = foreach B generate ABS(SUM(A.gpa)), COUNT(org.apache.pig.builtin.Distinct(A.name)), (MIN(A.gpa) + MAX(A.gpa))/2, group.age;
    353. 

  353. explain C;
    354. 

  354. </pre>
    355. 

  355. <p></p>
    356. 

  356. <p>In the above example:</p>
    357. 

  357. <ul>
    358. 

  358. 

  359. <li>The GROUP statement can be referred to as a whole or by accessing individual fields (as in the example). </li>
    360. 

  360. 

  361. <li>The GROUP statement and its elements can appear anywhere in the projection. </li>
    362. 

  362. 

  363. </ul>
    364. 

  364. <p>In the above example, a variety of expressions can be applied to algebraic functions including:</p>
    365. 

  365. <ul>
    366. 

  366. 

  367. <li>A column transformation function such as ABS can be applied to an algebraic function SUM.</li>
    368. 

  368. 

  369. <li>An algebraic function (COUNT) can be applied to another algebraic function (Distinct), but only the inner function is computed using the combiner. </li>
    370. 

  370. 

  371. <li>A mathematical expression can be applied to one or more algebraic functions. </li>
    372. 

  372. 

  373. </ul>
    374. 

  374. <p></p>
    375. 

  375. <p>You can check if the combiner is used for your query by running <a href="test.html#EXPLAIN">EXPLAIN</a> on the FOREACH alias as shown above. You should see the combine section in the MapReduce part of the plan:</p>
    376. 

  376. <pre class="code">
    377. 

  377. .....
    378. 

  378. Combine Plan
    379. 

  379. B: Local Rearrange[tuple]{bytearray}(false) - scope-42
    380. 

  380. | |
    381. 

  381. | Project[bytearray][0] - scope-43
    382. 

  382. |
    383. 

  383. |---C: New For Each(false,false,false)[bag] - scope-28
    384. 

  384. | |
    385. 

  385. | Project[bytearray][0] - scope-29
    386. 

  386. | |
    387. 

  387. | POUserFunc(org.apache.pig.builtin.SUM$Intermediate)[tuple] - scope-30
    388. 

  388. | |
    389. 

  389. | |---Project[bag][1] - scope-31
    390. 

  390. | |
    391. 

  391. | POUserFunc(org.apache.pig.builtin.Distinct$Intermediate)[tuple] - scope-32
    392. 

  392. | |
    393. 

  393. | |---Project[bag][2] - scope-33
    394. 

  394. |
    395. 

  395. |---POCombinerPackage[tuple]{bytearray} - scope-36--------
    396. 

  396. .....
    397. 

  397. </pre>
    398. 

  398. <p>The combiner is also used with a nested foreach as long as the only nested operation used is DISTINCT
    399. 

  399. (see <a href="basic.html#FOREACH">FOREACH</a> and <a href="basic.html#nestedblock">Example: Nested Block</a>).
    400. 

  400. </p>
    401. 

  401. <pre class="code">
    402. 

  402. A = load 'studenttab10k' as (name, age, gpa);
    403. 

  403. B = group A by age;
    404. 

  404. C = foreach B { D = distinct (A.name); generate group, COUNT(D);}
    405. 

  405. </pre>
    406. 

  406. <p></p>
    407. 

  407. <p>Finally, use of the combiner is influenced by the surrounding environment of the GROUP and FOREACH statements.</p>
    408. 

  408. <a name="When+the+Combiner+is+Not+Used"></a>
    409. 

  409. <h3 class="h4">When the Combiner is Not Used</h3>
    410. 

  410. <p>The combiner is generally not used if there is any operator that comes between the GROUP and FOREACH statements in the execution plan. Even if the statements are next to each other in your script, the optimizer might rearrange them. In this example, the optimizer will push FILTER above FOREACH which will prevent the use of the combiner:</p>
    411. 

  411. <pre class="code">
    412. 

  412. A = load 'studenttab10k' as (name, age, gpa);
    413. 

  413. B = group A by age;
    414. 

  414. C = foreach B generate group, COUNT (A);
    415. 

  415. D = filter C by group.age &lt;30;
    416. 

  416. </pre>
    417. 

  417. <p></p>
    418. 

  418. <p>Please note that the script above can be made more efficient by performing filtering before the GROUP statement:</p>
    419. 

  419. <pre class="code">
    420. 

  420. A = load 'studenttab10k' as (name, age, gpa);
    421. 

  421. B = filter A by age &lt;30;
    422. 

  422. C = group B by age;
    423. 

  423. D = foreach C generate group, COUNT (B);
    424. 

  424. </pre>
    425. 

  425. <p></p>
    426. 

  426. <p>
    427. 

  427. <strong>Note:</strong> One exception to the above rule is LIMIT. Starting with Pig 0.9, even if LIMIT comes between GROUP and FOREACH, the combiner will still be used. In this example, the optimizer will push LIMIT above FOREACH but this will not prevent the use of the combiner.</p>
    428. 

  428. <pre class="code">
    429. 

  429. A = load 'studenttab10k' as (name, age, gpa);
    430. 

  430. B = group A by age;
    431. 

  431. C = foreach B generate group, COUNT (A);
    432. 

  432. D = limit C 20;
    433. 

  433. </pre>
    434. 

  434. <p></p>
    435. 

  435. <p>The combiner is also not used in the case where multiple FOREACH statements are associated with the same GROUP:</p>
    436. 

  436. <pre class="code">
    437. 

  437. A = load 'studenttab10k' as (name, age, gpa);
    438. 

  438. B = group A by age;
    439. 

  439. C = foreach B generate group, COUNT (A);
    440. 

  440. D = foreach B generate group, MIN (A.gpa). MAX(A.gpa);
    441. 

  441. .....
    442. 

  442. </pre>
    443. 

  443. <p>Depending on your use case, it might be more efficient (improve performance) to split your script into multiple scripts.</p>
    444. 

  444. </div> 
    445. 

  445. 

  446. <!-- ================================================================== -->
    447. 

  447. <!-- HASH-BASED AGGREGATION IN MAP TASK-->
    448. 

  448.  
    449. 

  449. <a name="hash-based-aggregation"></a>
    450. 

  450. <h2 class="h3">Hash-based Aggregation in Map Task</h2>
    451. 

  451. <div class="section">
    452. 

  452. <p> To improve performance, hash-based aggregation will aggregate records in the map task before sending them to the combiner. This  optimization reduces the serializing/deserializing costs of the combiner by sending it fewer records.</p>
    453. 

  453. <p>
    454. 

  454. <strong>Turning On Off</strong>
    455. 

  455. </p>
    456. 

  456. <p>Hash-based aggregation has been shown to improve the speed of group-by operations by up to 50%. However, since this is a very new feature, it is currently turned OFF by default. To turn it ON, set the property pig.exec.mapPartAgg to true.</p>
    457. 

  457. <p>
    458. 

  458. <strong>Configuring</strong>
    459. 

  459. </p>
    460. 

  460. <p>If the group-by keys used for grouping don't result in a sufficient reduction in the number of records, the performance might be worse with this feature turned ON. To prevent this from happening, the feature turns itself off if the reduction in records sent to combiner is not more than a configurable threshold. This threshold can be set using the property pig.exec.mapPartAgg.minReduction. It is set to a default value of 10, which means that the number of records that get sent to the combiner should be reduced by a factor of 10 or more.</p>
    461. 

  461. </div>
    462. 

  462.   
    463. 

  463. <!-- ================================================================== -->
    464. 

  464. <!-- MEMORY MANAGEMENT -->
    465. 

  465. 

  466. <a name="memory-management"></a>
    467. 

  467. <h2 class="h3">Memory Management</h2>
    468. 

  468. <div class="section">
    469. 

  469. <p>Pig allocates a fix amount of memory to store bags and spills to disk as soon as the memory limit is reached. This is very similar to how Hadoop decides when to spill data accumulated by the combiner. </p>
    470. 

  470. <a name="memory-bags"></a>
    471. 

  471. <p id="memory-bags">The amount of memory allocated to bags is determined by pig.cachedbag.memusage; the default is set to 20% (0.2) of available memory. Note that this memory is shared across all large bags used by the application.</p>
    472. 

  472. </div> 
    473. 

  473. 

  474. <!-- ================================================================== -->
    475. 

  475. <!-- REDUCER ESTIMATION -->
    476. 

  476. 

  477. <a name="reducer-estimation"></a>
    478. 

  478. <h2 class="h3">Reducer Estimation</h2>
    479. 

  479. <div class="section">
    480. 

  480. <p>
    481. 

  481. By default Pig determines the number of reducers to use for a given job based on the size of the
    482. 

  482. input to the map phase. The input data size is divided by the
    483. 

  483. pig.exec.reducers.bytes.per.reducer parameter value (default 1GB) to determine the number of
    484. 

  484. reducers. The maximum number of reducers for a job is limited by the pig.exec.reducers.max parameter
    485. 

  485. (default 999).
    486. 

  486. </p>
    487. 

  487. <p>
    488. 

  488. The default reducer estimation algorithm described above can be overridden by setting the
    489. 

  489. pig.exec.reducer.estimator parameter to the fully qualified class name of an implementation of
    490. 

  490. <a href="http://svn.apache.org/repos/asf/pig/trunk/src/org/apache/pig/backend/hadoop/executionengine/mapReduceLayer/PigReducerEstimator.java">org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigReducerEstimator</a>.
    491. 

  491. The class must exist on the classpath of the process submitting the Pig job. If the
    492. 

  492. pig.exec.reducer.estimator.arg parameter is set, the value will be passed to a constructor
    493. 

  493. of the implementing class that takes a single String.
    494. 

  494. </p>
    495. 

  495. <p>
    496. 

  496. 

  497. </p>
    498. 

  498. </div>
    499. 

  499. 

  500. 

  501. <!-- ==================================================================== -->
    502. 

  502. <!-- MULTI-QUERY EXECUTION-->
    503. 

  503. 

  504. <a name="multi-query-execution"></a>
    505. 

  505. <h2 class="h3">Multi-Query Execution</h2>
    506. 

  506. <div class="section">
    507. 

  507. <p>With multi-query execution Pig processes an entire script or a batch of statements at once.</p>
    508. 

  508. <a name="Turning+it+On+or+Off"></a>
    509. 

  509. <h3 class="h4">Turning it On or Off</h3>
    510. 

  510. <p>Multi-query execution is turned on by default. 
    511. 

  511. 	To turn it off and revert to Pig's "execute-on-dump/store" behavior, use the "-M" or "-no_multiquery" options. </p>
    512. 

  512. <p>To run script "myscript.pig" without the optimization, execute Pig as follows: </p>
    513. 

  513. <pre class="code">
    514. 

  514. $ pig -M myscript.pig
    515. 

  515. or
    516. 

  516. $ pig -no_multiquery myscript.pig
    517. 

  517. </pre>
    518. 

  518. <a name="How+it+Works"></a>
    519. 

  519. <h3 class="h4">How it Works</h3>
    520. 

  520. <p>Multi-query execution introduces some changes:</p>
    521. 

  521. <ul>
    522. 

  522. 

  523. <li>
    524. 

  524. 

  525. <p>For batch mode execution, the entire script is first parsed to determine if intermediate tasks 
    526. 

  526. can be combined to reduce the overall amount of work that needs to be done; execution starts only after the parsing is completed 
    527. 

  527. (see the <a href="test.html#EXPLAIN">EXPLAIN</a> operator and the <a href="cmds.html#run">run</a> and <a href="cmds.html#exec">exec</a> commands). </p>
    528. 

  528. 

  529. 

  530. </li>
    531. 

  531. 

  532. <li>
    533. 

  533. 

  534. <p>Two run scenarios are optimized, as explained below: explicit and implicit splits, and storing intermediate results.</p>
    535. 

  535. 

  536. </li>
    537. 

  537. 

  538. </ul>
    539. 

  539. <a name="splits"></a>
    540. 

  540. <h4>Explicit and Implicit Splits</h4>
    541. 

  541. <p>There might be cases in which you want different processing on separate parts of the same data stream.</p>
    542. 

  542. <p>Example 1:</p>
    543. 

  543. <pre class="code">
    544. 

  544. A = LOAD ...
    545. 

  545. ...
    546. 

  546. SPLIT A' INTO B IF ..., C IF ...
    547. 

  547. ...
    548. 

  548. STORE B' ...
    549. 

  549. STORE C' ...
    550. 

  550. </pre>
    551. 

  551. <p>Example 2:</p>
    552. 

  552. <pre class="code">
    553. 

  553. A = LOAD ...
    554. 

  554. ...
    555. 

  555. B = FILTER A' ...
    556. 

  556. C = FILTER A' ...
    557. 

  557. ...
    558. 

  558. STORE B' ...
    559. 

  559. STORE C' ...
    560. 

  560. </pre>
    561. 

  561. <p>In prior Pig releases, Example 1 will dump A' to disk and then start jobs for B' and C'. 
    562. 

  562. Example 2 will execute all the dependencies of B' and store it and then execute all the dependencies of C' and store it. 
    563. 

  563. Both are equivalent, but the performance will be different. </p>
    564. 

  564. <p>Here's what the multi-query execution does to increase the performance: </p>
    565. 

  565. <ul>
    566. 

  566. 		
    567. 

  567. <li>
    568. 

  568. <p>For Example 2, adds an implicit split to transform the query to Example 1. 
    569. 

  569. 		This eliminates the processing of A' multiple times.</p>
    570. 

  570. </li>
    571. 

  571. 		
    572. 

  572. <li>
    573. 

  573. <p>Makes the split non-blocking and allows processing to continue. 
    574. 

  574. 		This helps reduce the amount of data that has to be stored right at the split.  </p>
    575. 

  575. </li>
    576. 

  576. 		
    577. 

  577. <li>
    578. 

  578. <p>Allows multiple outputs from a job. This way some results can be stored as a side-effect of the main job. 
    579. 

  579. 		This is also necessary to make the previous item work.  </p>
    580. 

  580. </li>
    581. 

  581. 		
    582. 

  582. <li>
    583. 

  583. <p>Allows multiple split branches to be carried on to the combiner/reducer. 
    584. 

  584. 		This reduces the amount of IO again in the case where multiple branches in the split can benefit from a combiner run. </p>
    585. 

  585. </li>
    586. 

  586. 	
    587. 

  587. </ul>
    588. 

  588. <a name="data-store-performance"></a>
    589. 

  589. <h4>Storing Intermediate Results</h4>
    590. 

  590. <p>Sometimes it is necessary to store intermediate results. </p>
    591. 

  591. <pre class="code">
    592. 

  592. A = LOAD ...
    593. 

  593. ...
    594. 

  594. STORE A'
    595. 

  595. ...
    596. 

  596. STORE A''
    597. 

  597. </pre>
    598. 

  598. <p>If the script doesn't re-load A' for the processing of A the steps above A' will be duplicated. 
    599. 

  599. This is a special case of Example 2 above, so the same steps are recommended. 
    600. 

  600. With multi-query execution, the script will process A and dump A' as a side-effect.</p>
    601. 

  601. <a name="store-dump"></a>
    602. 

  602. <h3 class="h4">Store vs. Dump</h3>
    603. 

  603. <p>With multi-query exection, you want to use <a href="basic.html#STORE">STORE</a> to save (persist) your results. 
    604. 

  604. 	You do not want to use <a href="test.html#DUMP">DUMP</a> as it will disable multi-query execution and is likely to slow down execution. (If you have included DUMP statements in your scripts for debugging purposes, you should remove them.) </p>
    605. 

  605. <p>DUMP Example: In this script, because the DUMP command is interactive, the multi-query execution will be disabled and two separate jobs will be created to execute this script. The first job will execute A &gt; B &gt; DUMP while the second job will execute A &gt; B &gt; C &gt; STORE.</p>
    606. 

  606. <pre class="code">
    607. 

  607. A = LOAD 'input' AS (x, y, z);
    608. 

  608. B = FILTER A BY x &gt; 5;
    609. 

  609. DUMP B;
    610. 

  610. C = FOREACH B GENERATE y, z;
    611. 

  611. STORE C INTO 'output';
    612. 

  612. </pre>
    613. 

  613. <p>STORE Example: In this script, multi-query optimization will kick in allowing the entire script to be executed as a single job. Two outputs are produced: output1 and output2.</p>
    614. 

  614. <pre class="code">
    615. 

  615. A = LOAD 'input' AS (x, y, z);
    616. 

  616. B = FILTER A BY x &gt; 5;
    617. 

  617. STORE B INTO 'output1';
    618. 

  618. C = FOREACH B GENERATE y, z;
    619. 

  619. STORE C INTO 'output2';	
    620. 

  620. </pre>
    621. 

  621. <a name="error-handling"></a>
    622. 

  622. <h3 class="h4">Error Handling</h3>
    623. 

  623. <p>With multi-query execution Pig processes an entire script or a batch of statements at once. 
    624. 

  624. 	By default Pig tries to run all the jobs that result from that, regardless of whether some jobs fail during execution. 
    625. 

  625. 	To check which jobs have succeeded or failed use one of these options. </p>
    626. 

  626. <p>First, Pig logs all successful and failed store commands. Store commands are identified by output path. 
    627. 

  627. 	At the end of execution a summary line indicates success, partial failure or failure of all store commands. </p>
    628. 

  628. <p>Second, Pig returns different code upon completion for these scenarios:</p>
    629. 

  629. <ul>
    630. 

  630. 		
    631. 

  631. <li>
    632. 

  632. <p>Return code 0: All jobs succeeded</p>
    633. 

  633. </li>
    634. 

  634. 		
    635. 

  635. <li>
    636. 

  636. <p>Return code 1: <em>Used for retrievable errors</em> 
    637. 

  637. </p>
    638. 

  638. </li>
    639. 

  639. 		
    640. 

  640. <li>
    641. 

  641. <p>Return code 2: All jobs have failed </p>
    642. 

  642. </li>
    643. 

  643. 		
    644. 

  644. <li>
    645. 

  645. <p>Return code 3: Some jobs have failed  </p>
    646. 

  646. </li>
    647. 

  647. 	
    648. 

  648. </ul>
    649. 

  649. <p></p>
    650. 

  650. <p>In some cases it might be desirable to fail the entire script upon detecting the first failed job. 
    651. 

  651. 	This can be achieved with the "-F" or "-stop_on_failure" command line flag. 
    652. 

  652. 	If used, Pig will stop execution when the first failed job is detected and discontinue further processing. 
    653. 

  653. 	This also means that file commands that come after a failed store in the script will not be executed (this can be used to create "done" files). </p>
    654. 

  654. <p>This is how the flag is used: </p>
    655. 

  655. <pre class="code">
    656. 

  656. $ pig -F myscript.pig
    657. 

  657. or
    658. 

  658. $ pig -stop_on_failure myscript.pig
    659. 

  659. </pre>
    660. 

  660. <a name="backward-compatibility"></a>
    661. 

  661. <h3 class="h4">Backward Compatibility</h3>
    662. 

  662. <p>Most existing Pig scripts will produce the same result with or without the multi-query execution. 
    663. 

  663. 	There are cases though where this is not true. Path names and schemes are discussed here.</p>
    664. 

  664. <p>Any script is parsed in it's entirety before it is sent to execution. Since the current directory can change 
    665. 

  665. 	throughout the script any path used in LOAD or STORE statement is translated to a fully qualified and absolute path.</p>
    666. 

  666. <p>In map-reduce mode, the following script will load from "hdfs://&lt;host&gt;:&lt;port&gt;/data1" and store into "hdfs://&lt;host&gt;:&lt;port&gt;/tmp/out1". </p>
    667. 

  667. <pre class="code">
    668. 

  668. cd /;
    669. 

  669. A = LOAD 'data1';
    670. 

  670. cd tmp;
    671. 

  671. STORE A INTO 'out1';
    672. 

  672. </pre>
    673. 

  673. <p>These expanded paths will be passed to any LoadFunc or Slicer implementation. 
    674. 

  674. 	In some cases this can cause problems, especially when a LoadFunc/Slicer is not used to read from a dfs file or path 
    675. 

  675. 	(for example, loading from an SQL database). </p>
    676. 

  676. <p>Solutions are to either: </p>
    677. 

  677. <ul>
    678. 

  678. 		
    679. 

  679. <li>
    680. 

  680. <p>Specify "-M" or "-no_multiquery" to revert to the old names</p>
    681. 

  681. </li>
    682. 

  682. 		
    683. 

  683. <li>
    684. 

  684. <p>Specify a custom scheme for the LoadFunc/Slicer </p>
    685. 

  685. </li>
    686. 

  686. 	
    687. 

  687. </ul>
    688. 

  688. <p>Arguments used in a LOAD statement that have a scheme other than "hdfs" or "file" will not be expanded and passed to the LoadFunc/Slicer unchanged.</p>
    689. 

  689. <p>In the SQL case, the SQLLoader function is invoked with 'sql://mytable'. </p>
    690. 

  690. <pre class="code">
    691. 

  691. A = LOAD 'sql://mytable' USING SQLLoader();
    692. 

  692. </pre>
    693. 

  693. <a name="Implicit-Dependencies"></a>
    694. 

  694. <h3 class="h4">Implicit Dependencies</h3>
    695. 

  695. <p>If a script has dependencies on the execution order outside of what Pig knows about, execution may fail. </p>
    696. 

  696. <a name="Example"></a>
    697. 

  697. <h4>Example</h4>
    698. 

  698. <p>In this script, MYUDF might try to read from out1, a file that A was just stored into. 
    699. 

  699. However, Pig does not know that MYUDF depends on the out1 file and might submit the jobs 
    700. 

  700. producing the out2 and out1 files at the same time.</p>
    701. 

  701. <pre class="code">
    702. 

  702. ...
    703. 

  703. STORE A INTO 'out1';
    704. 

  704. B = LOAD 'data2';
    705. 

  705. C = FOREACH B GENERATE MYUDF($0,'out1');
    706. 

  706. STORE C INTO 'out2';
    707. 

  707. </pre>
    708. 

  708. <p>To make the script work (to ensure that the right execution order is enforced) add the exec statement. 
    709. 

  709. The exec statement will trigger the execution of the statements that produce the out1 file. </p>
    710. 

  710. <pre class="code">
    711. 

  711. ...
    712. 

  712. STORE A INTO 'out1';
    713. 

  713. EXEC;
    714. 

  714. B = LOAD 'data2';
    715. 

  715. C = FOREACH B GENERATE MYUDF($0,'out1');
    716. 

  716. STORE C INTO 'out2';
    717. 

  717. </pre>
    718. 

  718. <a name="Example-N10217"></a>
    719. 

  719. <h4>Example</h4>
    720. 

  720. <p>In this script, the STORE/LOAD operators have different file paths; however, the LOAD operator depends on the STORE operator.</p>
    721. 

  721. <pre class="code">
    722. 

  722. A = LOAD '/user/xxx/firstinput' USING PigStorage();
    723. 

  723. B = group ....
    724. 

  724. C = .... agrregation function
    725. 

  725. STORE C INTO '/user/vxj/firstinputtempresult/days1';
    726. 

  726. ..
    727. 

  727. Atab = LOAD '/user/xxx/secondinput' USING  PigStorage();
    728. 

  728. Btab = group ....
    729. 

  729. Ctab = .... agrregation function
    730. 

  730. STORE Ctab INTO '/user/vxj/secondinputtempresult/days1';
    731. 

  731. ..
    732. 

  732. E = LOAD '/user/vxj/firstinputtempresult/' USING  PigStorage();
    733. 

  733. F = group ....
    734. 

  734. G = .... aggregation function
    735. 

  735. STORE G INTO '/user/vxj/finalresult1';
    736. 

  736. 

  737. Etab =LOAD '/user/vxj/secondinputtempresult/' USING  PigStorage();
    738. 

  738. Ftab = group ....
    739. 

  739. Gtab = .... aggregation function
    740. 

  740. STORE Gtab INTO '/user/vxj/finalresult2';
    741. 

  741. </pre>
    742. 

  742. <p>To make the script works, add the exec statement.  </p>
    743. 

  743. <pre class="code">
    744. 

  744. A = LOAD '/user/xxx/firstinput' USING PigStorage();
    745. 

  745. B = group ....
    746. 

  746. C = .... agrregation function
    747. 

  747. STORE C INTO '/user/vxj/firstinputtempresult/days1';
    748. 

  748. ..
    749. 

  749. Atab = LOAD '/user/xxx/secondinput' USING  PigStorage();
    750. 

  750. Btab = group ....
    751. 

  751. Ctab = .... agrregation function
    752. 

  752. STORE Ctab INTO '/user/vxj/secondinputtempresult/days1';
    753. 

  753. 

  754. EXEC;
    755. 

  755. 

  756. E = LOAD '/user/vxj/firstinputtempresult/' USING  PigStorage();
    757. 

  757. F = group ....
    758. 

  758. G = .... aggregation function
    759. 

  759. STORE G INTO '/user/vxj/finalresult1';
    760. 

  760. ..
    761. 

  761. Etab =LOAD '/user/vxj/secondinputtempresult/' USING  PigStorage();
    762. 

  762. Ftab = group ....
    763. 

  763. Gtab = .... aggregation function
    764. 

  764. STORE Gtab INTO '/user/vxj/finalresult2';
    765. 

  765. </pre>
    766. 

  766. </div>
    767. 

  767. 

  768. 

  769. <!-- ==================================================================== -->
    770. 

  770.  <!-- OPTIMIZATION RULES -->
    771. 

  771. 

  772. <a name="optimization-rules"></a>
    773. 

  773. <h2 class="h3">Optimization Rules</h2>
    774. 

  774. <div class="section">
    775. 

  775. <p>Pig supports various optimization rules. By default optimization, and all optimization rules, are turned on. 
    776. 

  776. To turn off optimiztion, use:</p>
    777. 

  777. <pre class="code">
    778. 

  778. pig -optimizer_off [opt_rule | all ]
    779. 

  779. </pre>
    780. 

  780. <p>Note that some rules are mandatory and cannot be turned off.</p>
    781. 

  781. <a name="FilterLogicExpressionSimplifier"></a>
    782. 

  782. <h3 class="h4">FilterLogicExpressionSimplifier</h3>
    783. 

  783. <p>This rule simplifies the expression in filter statement.</p>
    784. 

  784. <pre class="code">
    785. 

  785. 1) Constant pre-calculation 
    786. 

  786. 

  787. B = FILTER A BY a0 &gt; 5+7; 
    788. 

  788. is simplified to 
    789. 

  789. B = FILTER A BY a0 &gt; 12; 
    790. 

  790. 

  791. 2) Elimination of negations 
    792. 

  792. 

  793. B = FILTER A BY NOT (NOT(a0 &gt; 5) OR a &gt; 10); 
    794. 

  794. is simplified to 
    795. 

  795. B = FILTER A BY a0 &gt; 5 AND a &lt;= 10; 
    796. 

  796. 

  797. 3) Elimination of logical implied expression in AND 
    798. 

  798. 

  799. B = FILTER A BY (a0 &gt; 5 AND a0 &gt; 7); 
    800. 

  800. is simplified to 
    801. 

  801. B = FILTER A BY a0 &gt; 7; 
    802. 

  802. 

  803. 4) Elimination of logical implied expression in OR 
    804. 

  804. 

  805. B = FILTER A BY ((a0 &gt; 5) OR (a0 &gt; 6 AND a1 &gt; 15); 
    806. 

  806. is simplified to 
    807. 

  807. B = FILTER C BY a0 &gt; 5; 
    808. 

  808. 

  809. 5) Equivalence elimination 
    810. 

  810. 

  811. B = FILTER A BY (a0 v 5 AND a0 &gt; 5); 
    812. 

  812. is simplified to 
    813. 

  813. B = FILTER A BY a0 &gt; 5; 
    814. 

  814. 

  815. 6) Elimination of complementary expressions in OR 
    816. 

  816. 

  817. B = FILTER A BY (a0 &gt; 5 OR a0 &lt;= 5); 
    818. 

  818. is simplified to non-filtering 
    819. 

  819. 

  820. 7) Elimination of naive TRUE expression 
    821. 

  821. 

  822. B = FILTER A BY 1==1; 
    823. 

  823. is simplified to non-filtering 
    824. 

  824. </pre>
    825. 

  825. <a name="SplitFilter"></a>
    826. 

  826. <h3 class="h4">SplitFilter</h3>
    827. 

  827. <p>Split filter conditions so that we can push filter more aggressively.</p>
    828. 

  828. <pre class="code">
    829. 

  829. A = LOAD 'input1' as (a0, a1);
    830. 

  830. B = LOAD 'input2' as (b0, b1);
    831. 

  831. C = JOIN A by a0, B by b0;
    832. 

  832. D = FILTER C BY a1&gt;0 and b1&gt;0;
    833. 

  833. </pre>
    834. 

  834. <p>Here D will be splitted into:</p>
    835. 

  835. <pre class="code">
    836. 

  836. X = FILTER C BY a1&gt;0;
    837. 

  837. D = FILTER X BY b1&gt;0;
    838. 

  838. </pre>
    839. 

  839. <p>So "a1&gt;0" and "b1&gt;0" can be pushed up individually.</p>
    840. 

  840. <a name="PushUpFilter"></a>
    841. 

  841. <h3 class="h4">PushUpFilter</h3>
    842. 

  842. <p>The objective of this rule is to push the FILTER operators up the data flow graph. As a result, the number of records that flow through the pipeline is reduced. </p>
    843. 

  843. <pre class="code">
    844. 

  844. A = LOAD 'input';
    845. 

  845. B = GROUP A BY $0;
    846. 

  846. C = FILTER B BY $0 &lt; 10;
    847. 

  847. </pre>
    848. 

  848. <a name="MergeFilter"></a>
    849. 

  849. <h3 class="h4">MergeFilter</h3>
    850. 

  850. <p>Merge filter conditions after PushUpFilter rule to decrease the number of filter statements.</p>
    851. 

  851. <a name="PushDownForEachFlatten"></a>
    852. 

  852. <h3 class="h4">PushDownForEachFlatten</h3>
    853. 

  853. <p>The objective of this rule is to reduce the number of records that flow through the pipeline by moving FOREACH operators with a FLATTEN down the data flow graph. In the example shown below, it would be more efficient to move the foreach after the join to reduce the cost of the join operation.</p>
    854. 

  854. <pre class="code">
    855. 

  855. A = LOAD 'input' AS (a, b, c);
    856. 

  856. B = LOAD 'input2' AS (x, y, z);
    857. 

  857. C = FOREACH A GENERATE FLATTEN($0), B, C;
    858. 

  858. D = JOIN C BY $1, B BY $1;
    859. 

  859. </pre>
    860. 

  860. <a name="LimitOptimizer"></a>
    861. 

  861. <h3 class="h4">LimitOptimizer</h3>
    862. 

  862. <p>The objective of this rule is to push the LIMIT operator up the data flow graph (or down the tree for database folks). In addition, for top-k (ORDER BY followed by a LIMIT) the LIMIT is pushed into the ORDER BY.</p>
    863. 

  863. <pre class="code">
    864. 

  864. A = LOAD 'input';
    865. 

  865. B = ORDER A BY $0;
    866. 

  866. C = LIMIT B 10;
    867. 

  867. </pre>
    868. 

  868. <a name="ColumnMapKeyPrune"></a>
    869. 

  869. <h3 class="h4">ColumnMapKeyPrune</h3>
    870. 

  870. <p>Prune the loader to only load necessary columns. The performance gain is more significant if the corresponding loader support column pruning and only load necessary columns (See LoadPushDown.pushProjection). Otherwise, ColumnMapKeyPrune will insert a ForEach statement right after loader.</p>
    871. 

  871. <pre class="code">
    872. 

  872. A = load 'input' as (a0, a1, a2);
    873. 

  873. B = ORDER A by a0;
    874. 

  874. C = FOREACH B GENERATE a0, a1;
    875. 

  875. </pre>
    876. 

  876. <p>a2 is irrelevant in this query, so we can prune it earlier. The loader in this query is PigStorage and it supports column pruning. So we only load a0 and a1 from the input file.</p>
    877. 

  877. <p>ColumnMapKeyPrune also prunes unused map keys:</p>
    878. 

  878. <pre class="code">
    879. 

  879. A = load 'input' as (a0:map[]);
    880. 

  880. B = FOREACH A generate a0#'key1';
    881. 

  881. </pre>
    882. 

  882. <a name="AddForEach"></a>
    883. 

  883. <h3 class="h4">AddForEach</h3>
    884. 

  884. <p>Prune unused column as soon as possible. In addition to prune the loader in ColumnMapKeyPrune, we can prune a column as soon as it is not used in the rest of the script</p>
    885. 

  885. <pre class="code">
    886. 

  886. -- Original code: 
    887. 

  887. 

  888. A = LOAD 'input' AS (a0, a1, a2); 
    889. 

  889. B = ORDER A BY a0;
    890. 

  890. C = FILTER B BY a1&gt;0;
    891. 

  891. </pre>
    892. 

  892. <p>We can only prune a2 from the loader. However, a0 is never used after "ORDER BY". So we can drop a0 right after "ORDER BY" statement.</p>
    893. 

  893. <pre class="code">
    894. 

  894. -- Optimized code: 
    895. 

  895. 

  896. A = LOAD 'input' AS (a0, a1, a2); 
    897. 

  897. B = ORDER A BY a0;
    898. 

  898. B1 = FOREACH B GENERATE a1;  -- drop a0
    899. 

  899. C = FILTER B1 BY a1&gt;0;
    900. 

  900. </pre>
    901. 

  901. <a name="MergeForEach"></a>
    902. 

  902. <h3 class="h4">MergeForEach</h3>
    903. 

  903. <p>The objective of this rule is to merge together two feach statements, if these preconditions are met:</p>
    904. 

  904. <ul>
    905. 

  905. 

  906. <li>The foreach statements are consecutive.</li>
    907. 

  907. 

  908. <li>The first foreach statement does not contain flatten.</li>
    909. 

  909. 

  910. <li>The second foreach is not nested.</li>
    911. 

  911. 

  912. </ul>
    913. 

  913. <pre class="code">
    914. 

  914. -- Original code: 
    915. 

  915. 

  916. A = LOAD 'file.txt' AS (a, b, c); 
    917. 

  917. B = FOREACH A GENERATE a+b AS u, c-b AS v; 
    918. 

  918. C = FOREACH B GENERATE $0+5, v; 
    919. 

  919. 

  920. -- Optimized code: 
    921. 

  921. 

  922. A = LOAD 'file.txt' AS (a, b, c); 
    923. 

  923. C = FOREACH A GENERATE a+b+5, c-b;
    924. 

  924. </pre>
    925. 

  925. <a name="GroupByConstParallelSetter"></a>
    926. 

  926. <h3 class="h4">GroupByConstParallelSetter</h3>
    927. 

  927. <p>Force parallel "1" for "group all" statement. That's because even if we set parallel to N, only 1 reducer will be used in this case and all other reducer produce empty result.</p>
    928. 

  928. <pre class="code">
    929. 

  929. A = LOAD 'input';
    930. 

  930. B = GROUP A all PARALLEL 10;
    931. 

  931. </pre>
    932. 

  932. </div>
    933. 

  933. 

  934.   
    935. 

  935. <!-- ==================================================================== -->
    936. 

  936. <!-- PERFORMANCE ENHANCERS-->
    937. 

  937. 

  938. <a name="performance-enhancers"></a>
    939. 

  939. <h2 class="h3">Performance Enhancers</h2>
    940. 

  940. <div class="section">
    941. 

  941. <a name="Use+Optimization"></a>
    942. 

  942. <h3 class="h4">Use Optimization</h3>
    943. 

  943. <p>Pig supports various <a href="perf.html#Optimization-Rules">optimization rules</a> which are turned on by default. 
    944. 

  944. Become familiar with these rules.</p>
    945. 

  945. <a name="types"></a>
    946. 

  946. <h3 class="h4">Use Types</h3>
    947. 

  947. <p>If types are not specified in the load statement, Pig assumes the type of =double= for numeric computations. 
    948. 

  948. A lot of the time, your data would be much smaller, maybe, integer or long. Specifying the real type will help with 
    949. 

  949. speed of arithmetic computation. It has an additional advantage of early error detection. </p>
    950. 

  950. <pre class="code">
    951. 

  951. --Query 1
    952. 

  952. A = load 'myfile' as (t, u, v);
    953. 

  953. B = foreach A generate t + u;
    954. 

  954. 

  955. --Query 2
    956. 

  956. A = load 'myfile' as (t: int, u: int, v);
    957. 

  957. B = foreach A generate t + u;
    958. 

  958. </pre>
    959. 

  959. <p>The second query will run more efficiently than the first. In some of our queries with see 2x speedup. </p>
    960. 

  960. <a name="projection"></a>
    961. 

  961. <h3 class="h4">Project Early and Often </h3>
    962. 

  962. <p>Pig does not (yet) determine when a field is no longer needed and drop the field from the row. For example, say you have a query like: </p>
    963. 

  963. <pre class="code">
    964. 

  964. A = load 'myfile' as (t, u, v);
    965. 

  965. B = load 'myotherfile' as (x, y, z);
    966. 

  966. C = join A by t, B by x;
    967. 

  967. D = group C by u;
    968. 

  968. E = foreach D generate group, COUNT($1);
    969. 

  969. </pre>
    970. 

  970. <p>There is no need for v, y, or z to participate in this query.  And there is no need to carry both t and x past the join, just one will suffice. Changing the query above to the query below will greatly reduce the amount of data being carried through the map and reduce phases by pig. </p>
    971. 

  971. <pre class="code">
    972. 

  972. A = load 'myfile' as (t, u, v);
    973. 

  973. A1 = foreach A generate t, u;
    974. 

  974. B = load 'myotherfile' as (x, y, z);
    975. 

  975. B1 = foreach B generate x;
    976. 

  976. C = join A1 by t, B1 by x;
    977. 

  977. C1 = foreach C generate t, u;
    978. 

  978. D = group C1 by u;
    979. 

  979. E = foreach D generate group, COUNT($1);
    980. 

  980. </pre>
    981. 

  981. <p>Depending on your data, this can produce significant time savings. In queries similar to the example shown here we have seen total time drop by 50%.</p>
    982. 

  982. <a name="filter"></a>
    983. 

  983. <h3 class="h4">Filter Early and Often</h3>
    984. 

  984. <p>As with early projection, in most cases it is beneficial to apply filters as early as possible to reduce the amount of data flowing through the pipeline. </p>
    985. 

  985. <pre class="code">
    986. 

  986. -- Query 1
    987. 

  987. A = load 'myfile' as (t, u, v);
    988. 

  988. B = load 'myotherfile' as (x, y, z);
    989. 

  989. C = filter A by t == 1;
    990. 

  990. D = join C by t, B by x;
    991. 

  991. E = group D by u;
    992. 

  992. F = foreach E generate group, COUNT($1);
    993. 

  993. 

  994. -- Query 2
    995. 

  995. A = load 'myfile' as (t, u, v);
    996. 

  996. B = load 'myotherfile' as (x, y, z);
    997. 

  997. C = join A by t, B by x;
    998. 

  998. D = group C by u;
    999. 

  999. E = foreach D generate group, COUNT($1);
    1000. 

  1000. F = filter E by C.t == 1;
    1001. 

  1001. </pre>
    1002. 

  1002. <p>The first query is clearly more efficient than the second one because it reduces the amount of data going into the join. </p>
    1003. 

  1003. <p>One case where pushing filters up might not be a good idea is if the cost of applying filter is very high and only a small amount of data is filtered out. </p>
    1004. 

  1004. <a name="pipeline"></a>
    1005. 

  1005. <h3 class="h4">Reduce Your Operator Pipeline</h3>
    1006. 

  1006. <p>For clarity of your script, you might choose to split your projects into several steps for instance: </p>
    1007. 

  1007. <pre class="code">
    1008. 

  1008. A = load 'data' as (in: map[]);
    1009. 

  1009. -- get key out of the map
    1010. 

  1010. B = foreach A generate in#'k1' as k1, in#'k2' as k2;
    1011. 

  1011. -- concatenate the keys
    1012. 

  1012. C = foreach B generate CONCAT(k1, k2);
    1013. 

  1013. .......
    1014. 

  1014. </pre>
    1015. 

  1015. <p>While the example above is easier to read, you might want to consider combining the two foreach statements to improve your query performance: </p>
    1016. 

  1016. <pre class="code">
    1017. 

  1017. A = load 'data' as (in: map[]);
    1018. 

  1018. -- concatenate the keys from the map
    1019. 

  1019. B = foreach A generate CONCAT(in#'k1', in#'k2');
    1020. 

  1020. ....
    1021. 

  1021. </pre>
    1022. 

  1022. <p>The same goes for filters. </p>
    1023. 

  1023. <a name="algebraic-interface"></a>
    1024. 

  1024. <h3 class="h4">Make Your UDFs Algebraic</h3>
    1025. 

  1025. <p>Queries that can take advantage of the combiner generally ran much faster (sometimes several times faster) than the versions that don't. The latest code significantly improves combiner usage; however, you need to make sure you do your part. If you have a UDF that works on grouped data and is, by nature, algebraic (meaning their computation can be decomposed into multiple steps) make sure you implement it as such. For details on how to write algebraic UDFs, see <a href="udf.html#algebraic-interface">Algebraic Interface</a>.</p>
    1026. 

  1026. <pre class="code">
    1027. 

  1027. A = load 'data' as (x, y, z)
    1028. 

  1028. B = group A by x;
    1029. 

  1029. C = foreach B generate group, MyUDF(A);
    1030. 

  1030. ....
    1031. 

  1031. </pre>
    1032. 

  1032. <p>If <span class="codefrag">MyUDF</span> is algebraic, the query will use combiner and run much faster. You can run <span class="codefrag">explain</span> command on your query to make sure that combiner is used. </p>
    1033. 

  1033. <a name="accumulator-interface"></a>
    1034. 

  1034. <h3 class="h4">Use the Accumulator Interface</h3>
    1035. 

  1035. <p>
    1036. 

  1036. If your UDF can't be made Algebraic but is able to deal with getting input in chunks rather than all at once, consider implementing the Accumulator  interface to reduce the amount of memory used by your script. If your function <em>is</em> Algebraic and can be used on conjunction with Accumulator functions, you will need to implement the Accumulator interface as well as the Algebraic interface. For more information, see <a href="udf.html#Accumulator-Interface">Accumulator Interface</a>.</p>
    1037. 

  1037. <p>
    1038. 

  1038. <strong>Note:</strong> Pig automatically chooses the interface that it expects to provide the best performance: Algebraic &gt; Accumulator &gt; Default. </p>
    1039. 

  1039. <a name="nulls"></a>
    1040. 

  1040. <h3 class="h4">Drop Nulls Before a Join</h3>
    1041. 

  1041. <p>With the introduction of nulls, join and cogroup semantics were altered to work with nulls. The semantic for cogrouping with nulls is that nulls from a given input are grouped together, but nulls across inputs are not grouped together. This preserves the semantics of grouping (nulls are collected together from a single input to be passed to aggregate functions like COUNT) and the semantics of join (nulls are not joined across inputs). Since flattening an empty bag results in an empty row (and no output), in a standard join the rows with a null key will always be dropped. </p>
    1042. 

  1042. <p>This join</p>
    1043. 

  1043. <pre class="code">
    1044. 

  1044. A = load 'myfile' as (t, u, v);
    1045. 

  1045. B = load 'myotherfile' as (x, y, z);
    1046. 

  1046. C = join A by t, B by x;
    1047. 

  1047. </pre>
    1048. 

  1048. <p>is rewritten by Pig to </p>
    1049. 

  1049. <pre class="code">
    1050. 

  1050. A = load 'myfile' as (t, u, v);
    1051. 

  1051. B = load 'myotherfile' as (x, y, z);
    1052. 

  1052. C1 = cogroup A by t INNER, B by x INNER;
    1053. 

  1053. C = foreach C1 generate flatten(A), flatten(B);
    1054. 

  1054. </pre>
    1055. 

  1055. <p>Since the nulls from A and B won't be collected together, when the nulls are flattened we're guaranteed to have an empty bag, which will result in no output. So the null keys will be dropped. But they will not be dropped until the last possible moment. </p>
    1056. 

  1056. <p>If the query is rewritten to </p>
    1057. 

  1057. <pre class="code">
    1058. 

  1058. A = load 'myfile' as (t, u, v);
    1059. 

  1059. B = load 'myotherfile' as (x, y, z);
    1060. 

  1060. A1 = filter A by t is not null;
    1061. 

  1061. B1 = filter B by x is not null;
    1062. 

  1062. C = join A1 by t, B1 by x;
    1063. 

  1063. </pre>
    1064. 

  1064. <p>then the nulls will be dropped before the join.  Since all null keys go to a single reducer, if your key is null even a small percentage of the time the gain can be significant.  In one test where the key was null 7% of the time and the data was spread across 200 reducers, we saw a about a 10x speed up in the query by adding the early filters. </p>
    1065. 

  1065. <a name="join-optimizations"></a>
    1066. 

  1066. <h3 class="h4">Take Advantage of Join Optimizations</h3>
    1067. 

  1067. <p>
    1068. 

  1068. <strong>Regular Join Optimizations</strong>
    1069. 

  1069. </p>
    1070. 

  1070. <p>Optimization for regular joins ensures that the last table in the join is not brought into memory but streamed through instead. Optimization reduces the amount of memory used which means you can avoid spilling the data and also should be able to scale your query to larger data volumes. </p>
    1071. 

  1071. <p>To take advantage of this optimization, make sure that the table with the largest number of tuples per key is the last table in your query. 
    1072. 

  1072. In some of our tests we saw 10x performance improvement as the result of this optimization.</p>
    1073. 

  1073. <pre class="code">
    1074. 

  1074. small = load 'small_file' as (t, u, v);
    1075. 

  1075. large = load 'large_file' as (x, y, z);
    1076. 

  1076. C = join small by t, large by x;
    1077. 

  1077. </pre>
    1078. 

  1078. <p>
    1079. 

  1079. <strong>Specialized Join Optimizations</strong>
    1080. 

  1080. </p>
    1081. 

  1081. <p>Optimization can also be achieved using fragment replicate joins, skewed joins, and merge joins. 
    1082. 

  1082. For more information see <a href="perf.html#Specialized-Joins">Specialized Joins</a>.</p>
    1083. 

  1083. <a name="parallel"></a>
    1084. 

  1084. <h3 class="h4">Use the Parallel Features</h3>
    1085. 

  1085. <p>You can set the number of reduce tasks for the MapReduce jobs generated by Pig using two parallel features. 
    1086. 

  1086. (The parallel features only affect the number of reduce tasks. Map parallelism is determined by the input file, one map for each HDFS block.)</p>
    1087. 

  1087. <p>
    1088. 

  1088. <strong>You Set the Number of Reducers</strong>
    1089. 

  1089. </p>
    1090. 

  1090. <p>Use the <a href="cmds.html#set">set default parallel</a> command to set the number of reducers at the script level.</p>
    1091. 

  1091. <p>Alternatively, use the PARALLEL clause to set the number of reducers at the operator level. 
    1092. 

  1092. (In a script, the value set via the PARALLEL clause will override any value set via "set default parallel.")
    1093. 

  1093. You can include the PARALLEL clause with any operator that starts a reduce phase:  
    1094. 

  1094. <a href="basic.html#COGROUP">COGROUP</a>, 
    1095. 

  1095. <a href="basic.html#CROSS">CROSS</a>, 
    1096. 

  1096. <a href="basic.html#DISTINCT">DISTINCT</a>, 
    1097. 

  1097. <a href="basic.html#GROUP">GROUP</a>, 
    1098. 

  1098. <a href="basic.html#JOIN-inner">JOIN (inner)</a>, 
    1099. 

  1099. <a href="basic.html#JOIN-outer">JOIN (outer)</a>, and
    1100. 

  1100. <a href="basic.html#ORDER-BY">ORDER BY</a>.
    1101. 

  1101. </p>
    1102. 

  1102. <p>The number of reducers you need for a particular construct in Pig that forms a MapReduce boundary depends entirely on (1) your data and the number of intermediate keys you are generating in your mappers and (2) the partitioner and distribution of map (combiner) output keys. In the best cases we have seen that a reducer processing about 1 GB of data behaves efficiently.</p>
    1103. 

  1103. <p>
    1104. 

  1104. <strong>Let Pig Set the Number of Reducers</strong>
    1105. 

  1105. </p>
    1106. 

  1106. <p>If  neither "set default parallel" nor the PARALLEL clause are used, Pig sets the number of reducers using a heuristic based on the size of the input data. You can set the values for these properties:</p>
    1107. 

  1107. <ul>
    1108. 

  1108. 	
    1109. 

  1109. <li>pig.exec.reducers.bytes.per.reducer - Defines the number of input bytes per reduce; default value is 1000*1000*1000 (1GB).</li>
    1110. 

  1110. 	
    1111. 

  1111. <li>pig.exec.reducers.max - Defines the upper bound on the number of reducers; default is 999. </li>
    1112. 

  1112. 

  1113. </ul>
    1114. 

  1114. <p></p>
    1115. 

  1115. <p>The formula, shown below, is very simple and will improve over time. The computed value takes all inputs within the script into account and applies the computed value to all the jobs within Pig script.</p>
    1116. 

  1116. <p>
    1117. 

  1117. <span class="codefrag">#reducers = MIN (pig.exec.reducers.max, total input size (in bytes) / bytes per reducer) </span>
    1118. 

  1118. </p>
    1119. 

  1119. <p>
    1120. 

  1120. <strong>Examples</strong>
    1121. 

  1121. </p>
    1122. 

  1122. <p>In this example PARALLEL is used with the GROUP operator. </p>
    1123. 

  1123. <pre class="code">
    1124. 

  1124. A = LOAD 'myfile' AS (t, u, v);
    1125. 

  1125. B = GROUP A BY t PARALLEL 18;
    1126. 

  1126. ...
    1127. 

  1127. </pre>
    1128. 

  1128. <p>In this example all the MapReduce jobs that get launched use 20 reducers.</p>
    1129. 

  1129. <pre class="code">
    1130. 

  1130. SET default_parallel 20;
    1131. 

  1131. A = LOAD &lsquo;myfile.txt&rsquo; USING PigStorage() AS (t, u, v);
    1132. 

  1132. B = GROUP A BY t;
    1133. 

  1133. C = FOREACH B GENERATE group, COUNT(A.t) as mycount;
    1134. 

  1134. D = ORDER C BY mycount;
    1135. 

  1135. STORE D INTO &lsquo;mysortedcount&rsquo; USING PigStorage();
    1136. 

  1136. </pre>
    1137. 

  1137. <a name="limit"></a>
    1138. 

  1138. <h3 class="h4">Use the LIMIT Operator</h3>
    1139. 

  1139. <p>Often you are not interested in the entire output but rather a sample or top results. In such cases, using LIMIT can yield a much better performance as we push the limit as high as possible to minimize the amount of data travelling through the pipeline. </p>
    1140. 

  1140. <p>Sample: 
    1141. 

  1141. </p>
    1142. 

  1142. <pre class="code">
    1143. 

  1143. A = load 'myfile' as (t, u, v);
    1144. 

  1144. B = limit A 500;
    1145. 

  1145. </pre>
    1146. 

  1146. <p>Top results: </p>
    1147. 

  1147. <pre class="code">
    1148. 

  1148. A = load 'myfile' as (t, u, v);
    1149. 

  1149. B = order A by t;
    1150. 

  1150. C = limit B 500;
    1151. 

  1151. </pre>
    1152. 

  1152. <a name="distinct"></a>
    1153. 

  1153. <h3 class="h4">Prefer DISTINCT over GROUP BY/GENERATE</h3>
    1154. 

  1154. <p>To extract unique values from a column in a relation you can use DISTINCT or GROUP BY/GENERATE. DISTINCT is the preferred method; it is faster and more efficient.</p>
    1155. 

  1155. <p>Example using GROUP BY - GENERATE:</p>
    1156. 

  1156. <pre class="code">
    1157. 

  1157. A = load 'myfile' as (t, u, v);
    1158. 

  1158. B = foreach A generate u;
    1159. 

  1159. C = group B by u;
    1160. 

  1160. D = foreach C generate group as uniquekey;
    1161. 

  1161. dump D; 
    1162. 

  1162. </pre>
    1163. 

  1163. <p>Example using DISTINCT:</p>
    1164. 

  1164. <pre class="code">
    1165. 

  1165. A = load 'myfile' as (t, u, v);
    1166. 

  1166. B = foreach A generate u;
    1167. 

  1167. C = distinct B;
    1168. 

  1168. dump C; 
    1169. 

  1169. </pre>
    1170. 

  1170. <a name="compression"></a>
    1171. 

  1171. <h3 class="h4">Compress the Results of Intermediate Jobs</h3>
    1172. 

  1172. <p>If your Pig script generates a sequence of MapReduce jobs, you can compress the output of the intermediate jobs using LZO compression. (Use the <a href="test.html#EXPLAIN">EXPLAIN</a> operator to determine if your script produces multiple MapReduce Jobs.)</p>
    1173. 

  1173. <p>By doing this, you will save HDFS space used to store the intermediate data used by PIG and potentially improve query execution speed. In general, the more intermediate data that is generated, the more benefits in storage and speed that result.</p>
    1174. 

  1174. <p>You can set the value for these properties:</p>
    1175. 

  1175. <ul>
    1176. 

  1176. 	
    1177. 

  1177. <li>pig.tmpfilecompression - Determines if the temporary files should be compressed or not (set to false by default).</li>
    1178. 

  1178. 	
    1179. 

  1179. <li>pig.tmpfilecompression.codec - Specifies which compression codec to use. Currently, Pig accepts "gz" and "lzo" as possible values. However, because LZO is under GPL license (and disabled by default) you will need to configure your cluster to use the LZO codec to take advantage of this feature. For details, see http://code.google.com/p/hadoop-gpl-compression/wiki/FAQ.</li>
    1180. 

  1180. 

  1181. </ul>
    1182. 

  1182. <p></p>
    1183. 

  1183. <p>On the non-trivial queries (one ran longer than a couple of minutes) we saw significant improvements both in terms of query latency and space usage. For some queries we saw up to 96% disk saving and up to 4x query speed up. Of course, the performance characteristics are very much query and data dependent and testing needs to be done to determine gains. We did not see any slowdown in the tests we peformed which means that you are at least saving on space while using compression.</p>
    1184. 

  1184. <p>With gzip we saw a better compression (96-99%) but at a cost of 4% slowdown. Thus, we don't recommend using gzip. </p>
    1185. 

  1185. <p>
    1186. 

  1186. <strong>Example</strong>
    1187. 

  1187. </p>
    1188. 

  1188. <pre class="code">
    1189. 

  1189. -- launch Pig script using lzo compression 
    1190. 

  1190. 

  1191. java -cp $PIG_HOME/pig.jar 
    1192. 

  1192. -Djava.library.path=&lt;path to the lzo library&gt; 
    1193. 

  1193. -Dpig.tmpfilecompression=true 
    1194. 

  1194. -Dpig.tmpfilecompression.codec=lzo org.apache.pig.Main  myscript.pig 
    1195. 

  1195. </pre>
    1196. 

  1196. <a name="combine-files"></a>
    1197. 

  1197. <h3 class="h4">Combine Small Input Files</h3>
    1198. 

  1198. <p>Processing input (either user input or intermediate input) from multiple small files can be inefficient because a separate map has to be created for each file. Pig can now combined small files so that they are processed as a single map.</p>
    1199. 

  1199. <p>You can set the values for these properties:</p>
    1200. 

  1200. <ul>
    1201. 

  1201. 

  1202. <li>pig.maxCombinedSplitSize &ndash; Specifies the size, in bytes, of data to be processed by a single map. Smaller files are combined untill this size is reached. </li>
    1203. 

  1203. 

  1204. <li>pig.splitCombination &ndash; Turns combine split files on or off (set to &ldquo;true&rdquo; by default).</li>
    1205. 

  1205. 

  1206. </ul>
    1207. 

  1207. <p></p>
    1208. 

  1208. <p>This feature works with <a href="func.html#PigStorage">PigStorage</a>. However, if you are using a custom loader, please note the following:</p>
    1209. 

  1209. <ul>
    1210. 

  1210. 

  1211. <li>If your loader implementation makes use of the PigSplit object passed through the prepareToRead method, then you may need to rebuild the loader since the definition of PigSplit has been modified. </li>
    1212. 

  1212. 

  1213. <li>The loader must be stateless across the invocations to the prepareToRead method. That is, the method should reset any internal states that are not affected by the RecordReader argument.</li>
    1214. 

  1214. 

  1215. <li>If a loader implements IndexableLoadFunc, or implements OrderedLoadFunc and CollectableLoadFunc, its input splits won't be subject to possible combinations.</li>
    1216. 

    1217. 

  1217. </ul>
    1218. 

  1218. <p></p>
    1219. 

  1219. </div>
    1220. 

  1220.   
    1221. 

  1221. <!-- ==================================================================== -->
    1222. 

  1222. <!-- SPECIALIZED JOINS-->
    1223. 

  1223.   
    1224. 

  1224. <a name="specialized-joins"></a>
    1225. 

  1225. <h2 class="h3">Specialized Joins</h2>
    1226. 

  1226. <div class="section">
    1227. 

  1227. <a name="replicated-joins"></a>
    1228. 

  1228. <h3 class="h4">Replicated Joins</h3>
    1229. 

  1229. <p>Fragment replicate join is a special type of join that works well if one or more relations are small enough to fit into main memory. 
    1230. 

  1230. In such cases, Pig can perform a very efficient join because all of the hadoop work is done on the map side. In this type of join the 
    1231. 

  1231. large relation is followed by one or more small relations. The small relations must be small enough to fit into main memory; if they 
    1232. 

  1232. don't, …
    1233.

Large files files are truncated, but you can click here to view the full file