Apache Pig - คู่มือฉบับย่อ

Apache Pig คืออะไร?

Apache Pig เป็นนามธรรมเหนือ MapReduce เป็นเครื่องมือ / แพลตฟอร์มที่ใช้ในการวิเคราะห์ชุดข้อมูลขนาดใหญ่ที่แสดงเป็นกระแสข้อมูล โดยทั่วไปจะใช้หมูกับHadoop; เราสามารถดำเนินการจัดการข้อมูลทั้งหมดใน Hadoop โดยใช้ Apache Pig

ในการเขียนโปรแกรมวิเคราะห์ข้อมูล Pig ให้ภาษาระดับสูงที่เรียกว่า Pig Latin. ภาษานี้จัดเตรียมตัวดำเนินการต่างๆซึ่งโปรแกรมเมอร์สามารถพัฒนาฟังก์ชันของตนเองสำหรับการอ่านเขียนและประมวลผลข้อมูล

เพื่อวิเคราะห์ข้อมูลโดยใช้ Apache Pigโปรแกรมเมอร์ต้องเขียนสคริปต์โดยใช้ภาษา Pig Latin สคริปต์ทั้งหมดเหล่านี้ถูกแปลงภายในเป็นแผนที่และลดงาน Apache Pig มีส่วนประกอบที่เรียกว่าPig Engine ที่ยอมรับสคริปต์ Pig Latin เป็นอินพุตและแปลงสคริปต์เหล่านั้นเป็นงาน MapReduce

ทำไมเราต้องใช้ Apache Pig?

โปรแกรมเมอร์ที่ไม่ค่อยถนัด Java มักใช้ในการต่อสู้กับ Hadoop โดยเฉพาะอย่างยิ่งในขณะที่ทำงาน MapReduce ใด ๆ Apache Pig เป็นประโยชน์สำหรับโปรแกรมเมอร์ทุกคน

• การใช้ Pig Latinโปรแกรมเมอร์สามารถทำงาน MapReduce ได้อย่างง่ายดายโดยไม่ต้องพิมพ์โค้ดที่ซับซ้อนใน Java

• Apache Pig ใช้ multi-query approachซึ่งจะช่วยลดความยาวของรหัส ตัวอย่างเช่นการดำเนินการที่ต้องการให้คุณพิมพ์โค้ด 200 บรรทัด (LoC) ใน Java สามารถทำได้อย่างง่ายดายโดยพิมพ์น้อยเพียง 10 LoC ใน Apache Pig ในที่สุด Apache Pig จะลดเวลาในการพัฒนาลงเกือบ 16 เท่า

• Pig Latin คือ SQL-like language และเรียนรู้ Apache Pig ได้ง่ายเมื่อคุณคุ้นเคยกับ SQL

• Apache Pig มีตัวดำเนินการในตัวจำนวนมากเพื่อรองรับการดำเนินการกับข้อมูลเช่นการรวมตัวกรองการสั่งซื้อและอื่น ๆ นอกจากนี้ยังมีประเภทข้อมูลที่ซ้อนกันเช่นสิ่งที่เพิ่มขึ้นถุงและแผนที่ที่ขาดหายไปจาก MapReduce

คุณสมบัติของหมู

Apache Pig มาพร้อมกับคุณสมบัติดังต่อไปนี้ -

• Rich set of operators - มีตัวดำเนินการจำนวนมากในการดำเนินการเช่น join, sort, filer ฯลฯ

• Ease of programming - Pig Latin คล้ายกับ SQL และง่ายต่อการเขียนสคริปต์ Pig ถ้าคุณเก่ง SQL

• Optimization opportunities - งานใน Apache Pig จะปรับการทำงานให้เหมาะสมโดยอัตโนมัติดังนั้นโปรแกรมเมอร์จึงต้องเน้นเฉพาะความหมายของภาษาเท่านั้น

• Extensibility - การใช้ตัวดำเนินการที่มีอยู่ผู้ใช้สามารถพัฒนาฟังก์ชันของตนเองเพื่ออ่านประมวลผลและเขียนข้อมูลได้

• UDF’s - หมูให้สิ่งอำนวยความสะดวกในการสร้าง User-defined Functions ในภาษาโปรแกรมอื่น ๆ เช่น Java และเรียกใช้หรือฝังไว้ใน Pig Scripts

• Handles all kinds of data- Apache Pig วิเคราะห์ข้อมูลทุกประเภททั้งแบบมีโครงสร้างและแบบไม่มีโครงสร้าง จัดเก็บผลลัพธ์ใน HDFS

Apache Pig กับ MapReduce

รายการด้านล่างนี้คือความแตกต่างที่สำคัญระหว่าง Apache Pig และ MapReduce

หมูอาปาเช่	MapReduce
Apache Pig เป็นภาษาโฟลว์ข้อมูล	MapReduce คือกระบวนทัศน์การประมวลผลข้อมูล
มันเป็นภาษาระดับสูง	MapReduce อยู่ในระดับต่ำและแข็ง
การดำเนินการเข้าร่วมใน Apache Pig นั้นค่อนข้างง่าย	ค่อนข้างยากใน MapReduce ที่จะดำเนินการเข้าร่วมระหว่างชุดข้อมูล
โปรแกรมเมอร์มือใหม่ที่มีความรู้พื้นฐานเกี่ยวกับ SQL สามารถทำงานกับ Apache Pig ได้อย่างสะดวก	การเปิดรับ Java จะต้องทำงานร่วมกับ MapReduce
Apache Pig ใช้วิธีการค้นหาหลายคำซึ่งจะช่วยลดความยาวของรหัสลงได้มาก	MapReduce จะต้องใช้จำนวนบรรทัดเพิ่มขึ้นเกือบ 20 เท่าในการทำงานเดียวกัน
ไม่จำเป็นต้องมีการรวบรวม ในการดำเนินการตัวดำเนินการ Apache Pig ทุกตัวจะถูกแปลงภายในเป็นงาน MapReduce	งาน MapReduce มีขั้นตอนการรวบรวมที่ยาวนาน

Apache Pig กับ SQL

ด้านล่างนี้คือความแตกต่างที่สำคัญระหว่าง Apache Pig และ SQL

หมู	SQL
Pig Latin คือ procedural ภาษา.	SQL คือไฟล์ declarative ภาษา.
ใน Apache Pig schemaเป็นทางเลือก เราสามารถจัดเก็บข้อมูลโดยไม่ต้องออกแบบสคีมา (ค่าจะถูกเก็บเป็นไฟล์$01, $02 เป็นต้น)	สคีมาบังคับใน SQL
โมเดลข้อมูลใน Apache Pig คือ nested relational.	โมเดลข้อมูลที่ใช้ใน SQL is flat relational.
Apache Pig ให้โอกาสที่ จำกัด สำหรับ Query optimization.	มีโอกาสมากขึ้นสำหรับการเพิ่มประสิทธิภาพแบบสอบถามใน SQL

นอกเหนือจากความแตกต่างข้างต้นแล้ว Apache Pig Latin -

• อนุญาตให้แยกในท่อ
• ช่วยให้นักพัฒนาสามารถจัดเก็บข้อมูลได้ทุกที่ในท่อ
• ประกาศแผนการดำเนินการ
• จัดเตรียมตัวดำเนินการเพื่อดำเนินการฟังก์ชัน ETL (Extract, Transform และ Load)

Apache Pig Vs Hive

ทั้ง Apache Pig และ Hive ใช้เพื่อสร้างงาน MapReduce และในบางกรณี Hive ทำงานบน HDFS ในลักษณะเดียวกันกับที่ Apache Pig ทำ ในตารางต่อไปนี้เราได้ระบุประเด็นสำคัญบางประการที่ทำให้ Apache Pig แตกต่างจาก Hive

หมูอาปาเช่	รัง
Apache Pig ใช้ภาษาที่เรียกว่า Pig Latin. เดิมถูกสร้างขึ้นที่Yahoo.	Hive ใช้ภาษาที่เรียกว่า HiveQL. เดิมถูกสร้างขึ้นที่Facebook.
Pig Latin เป็นภาษาโฟลว์ข้อมูล	HiveQL เป็นภาษาประมวลผลแบบสอบถาม
Pig Latin เป็นภาษาขั้นตอนและเหมาะกับกระบวนทัศน์ท่อ	HiveQL เป็นภาษาประกาศ
Apache Pig สามารถจัดการข้อมูลที่มีโครงสร้างไม่มีโครงสร้างและกึ่งโครงสร้าง	ไฮฟ์ส่วนใหญ่เป็นข้อมูลที่มีโครงสร้าง

การใช้งาน Apache Pig

โดยทั่วไปนักวิทยาศาสตร์ข้อมูลจะใช้ Apache Pig ในการปฏิบัติงานที่เกี่ยวข้องกับการประมวลผลแบบเฉพาะกิจและการสร้างต้นแบบอย่างรวดเร็ว ใช้ Apache Pig -

• เพื่อประมวลผลแหล่งข้อมูลขนาดใหญ่เช่นบันทึกเว็บ
• เพื่อดำเนินการประมวลผลข้อมูลสำหรับแพลตฟอร์มการค้นหา
• เพื่อประมวลผลการโหลดข้อมูลที่มีความสำคัญกับเวลา

Apache Pig - ประวัติศาสตร์

ใน 2006Apache Pig ได้รับการพัฒนาเป็นโครงการวิจัยที่ Yahoo โดยเฉพาะอย่างยิ่งเพื่อสร้างและดำเนินการงาน MapReduce ในทุกชุดข้อมูล ใน2007Apache Pig เปิดแหล่งที่มาผ่าน Apache incubator ใน2008Apache Pig รุ่นแรกออกมาแล้ว ใน2010Apache Pig จบการศึกษาจากโครงการระดับบนสุดของ Apache

ภาษาที่ใช้ในการวิเคราะห์ข้อมูลใน Hadoop โดยใช้ Pig เรียกว่า Pig Latin. เป็นภาษาประมวลผลข้อมูลระดับสูงซึ่งมีชุดข้อมูลและตัวดำเนินการที่หลากหลายเพื่อดำเนินการต่างๆกับข้อมูล

ในการทำงานเฉพาะโปรแกรมเมอร์โดยใช้ Pig โปรแกรมเมอร์ต้องเขียนสคริปต์ Pig โดยใช้ภาษา Pig Latin และดำเนินการโดยใช้กลไกการดำเนินการใด ๆ (Grunt Shell, UDFs, Embedded) หลังจากดำเนินการสคริปต์เหล่านี้จะผ่านชุดของการเปลี่ยนแปลงที่ใช้โดย Pig Framework เพื่อสร้างผลลัพธ์ที่ต้องการ

ภายใน Apache Pig จะแปลงสคริปต์เหล่านี้เป็นชุดของงาน MapReduce ดังนั้นจึงทำให้งานของโปรแกรมเมอร์ง่ายขึ้น สถาปัตยกรรมของ Apache Pig แสดงไว้ด้านล่าง

ส่วนประกอบของ Apache Pig

ดังแสดงในรูปมีส่วนประกอบต่างๆในกรอบ Apache Pig ให้เรามาดูส่วนประกอบหลัก ๆ

Parser

ในขั้นต้นสคริปต์หมูจะถูกจัดการโดย Parser ตรวจสอบไวยากรณ์ของสคริปต์ตรวจสอบประเภทและตรวจสอบเบ็ดเตล็ดอื่น ๆ ผลลัพธ์ของ parser จะเป็น DAG (กราฟ acyclic กำกับ) ซึ่งแสดงถึงคำสั่ง Pig Latin และตัวดำเนินการเชิงตรรกะ

ใน DAG ตัวดำเนินการเชิงตรรกะของสคริปต์จะแสดงเป็นโหนดและกระแสข้อมูลจะแสดงเป็นขอบ

เครื่องมือเพิ่มประสิทธิภาพ

แผนลอจิคัล (DAG) ถูกส่งผ่านไปยังเครื่องมือเพิ่มประสิทธิภาพเชิงตรรกะซึ่งดำเนินการเพิ่มประสิทธิภาพเชิงตรรกะเช่นการฉายภาพและการเลื่อนลง

คอมไพเลอร์

คอมไพเลอร์รวบรวมแผนลอจิคัลที่ปรับให้เหมาะสมเป็นชุดของงาน MapReduce

กลไกการดำเนินการ

ในที่สุดงาน MapReduce จะถูกส่งไปยัง Hadoop ตามลำดับ สุดท้ายงาน MapReduce เหล่านี้จะถูกดำเนินการบน Hadoop เพื่อให้ได้ผลลัพธ์ที่ต้องการ

Pig Latin Data Model

แบบจำลองข้อมูลของ Pig Latin จะซ้อนกันอย่างสมบูรณ์และอนุญาตให้มีประเภทข้อมูลที่ไม่ใช่อะตอมที่ซับซ้อนเช่น map และ tuple. ด้านล่างนี้คือการแสดงแผนภาพของโมเดลข้อมูลของ Pig Latin

อะตอม

ค่าเดียวใด ๆ ใน Pig Latin โดยไม่คำนึงถึงข้อมูลประเภทนั้นเรียกว่า an Atom. มันถูกจัดเก็บเป็นสตริงและสามารถใช้เป็นสตริงและตัวเลขได้ int, long, float, double, chararray และ bytearray เป็นค่าอะตอมของ Pig ข้อมูลหรือค่าอะตอมอย่างง่ายเรียกว่า afield.

Example - 'ราชา' หรือ '30'

ทูเพิล

เร็กคอร์ดที่สร้างขึ้นโดยชุดฟิลด์ที่เรียงลำดับเรียกว่าทูเพิลฟิลด์สามารถเป็นประเภทใดก็ได้ ทูเปิลคล้ายกับแถวในตาราง RDBMS

Example - (ราชา 30)

ถุง

กระเป๋าเป็นชุดทูเปิลที่ไม่เรียงลำดับ กล่าวอีกนัยหนึ่งคอลเลกชันของสิ่งทอ (ไม่ซ้ำกัน) เรียกว่ากระเป๋า ทูเปิลแต่ละอันสามารถมีฟิลด์จำนวนเท่าใดก็ได้ (สคีมาที่ยืดหยุ่น) กระเป๋าแทนด้วย "{}" คล้ายกับตารางใน RDBMS แต่ต่างจากตารางใน RDBMS ไม่จำเป็นที่ทุกทูเพิลจะมีจำนวนฟิลด์เท่ากันหรือฟิลด์ในตำแหน่งเดียวกัน (คอลัมน์) จะมีประเภทเดียวกัน

Example - {(ราชา, 30), (โมฮัมหมัด, 45)}

กระเป๋าสามารถเป็นฟิลด์ที่สัมพันธ์กันได้ ในบริบทนั้นเรียกว่าinner bag.

Example- {ราชา 30, {9848022338, [email protected],} }

แผนที่

แผนที่ (หรือแผนที่ข้อมูล) คือชุดของคู่คีย์ - ค่า keyต้องเป็นประเภทอักขระและควรไม่ซ้ำกัน valueอาจเป็นประเภทใดก็ได้ แสดงโดย "[]"

Example - [ชื่อ # ราชาอายุ # 30]

ความสัมพันธ์

ความสัมพันธ์คือถุงสิ่งทอ ความสัมพันธ์ใน Pig Latin ไม่มีการเรียงลำดับ (ไม่มีการรับประกันว่า tuples จะถูกประมวลผลตามลำดับใด ๆ )

บทนี้จะอธิบายวิธีการดาวน์โหลดติดตั้งและตั้งค่า Apache Pig ในระบบของคุณ

ข้อกำหนดเบื้องต้น

จำเป็นอย่างยิ่งที่คุณต้องติดตั้ง Hadoop และ Java ในระบบของคุณก่อนที่จะไปใช้งาน Apache Pig ดังนั้นก่อนติดตั้ง Apache Pig ให้ติดตั้ง Hadoop และ Java โดยทำตามขั้นตอนที่ระบุในลิงค์ต่อไปนี้ -

http://www.tutorialspoint.com/hadoop/hadoop_enviornment_setup.htm

ดาวน์โหลด Apache Pig

ก่อนอื่นให้ดาวน์โหลดเวอร์ชันล่าสุดของ Apache Pig จากเว็บไซต์ต่อไปนี้ - https://pig.apache.org/

ขั้นตอนที่ 1

เปิดหน้าแรกของเว็บไซต์ Apache Pig ภายใต้ส่วนNews, คลิกที่ลิงค์ release page ดังแสดงในภาพรวมต่อไปนี้

ขั้นตอนที่ 2

เมื่อคลิกลิงก์ที่ระบุคุณจะถูกเปลี่ยนเส้นทางไปยังไฟล์ Apache Pig Releasesหน้า. ในหน้านี้ภายใต้Download คุณจะมีลิงค์สองลิงค์คือ Pig 0.8 and later และ Pig 0.7 and before. คลิกที่ลิงค์Pig 0.8 and laterจากนั้นคุณจะถูกเปลี่ยนเส้นทางไปยังหน้าที่มีชุดกระจก

ขั้นตอนที่ 3

เลือกและคลิกกระจกบานใดบานหนึ่งตามที่แสดงด้านล่าง

ขั้นตอนที่ 4

กระจกเหล่านี้จะพาคุณไปที่ Pig Releasesหน้า. หน้านี้มี Apache Pig เวอร์ชันต่างๆ คลิกเวอร์ชันล่าสุดจากนั้น

ขั้นตอนที่ 5

ภายในโฟลเดอร์เหล่านี้คุณจะมีซอร์สและไฟล์ไบนารีของ Apache Pig ในรูปแบบต่างๆ ดาวน์โหลดไฟล์ tar ของซอร์สและไฟล์ไบนารีของ Apache Pig 0.15pig0.15.0-src.tar.gz และ pig-0.15.0.tar.gz.

ติดตั้ง Apache Pig

หลังจากดาวน์โหลดซอฟต์แวร์ Apache Pig แล้วให้ติดตั้งในระบบ Linux ของคุณโดยทำตามขั้นตอนด้านล่าง

ขั้นตอนที่ 1

สร้างไดเร็กทอรีที่มีชื่อ Pig ในไดเร็กทอรีเดียวกับที่ไดเร็กทอรีการติดตั้งของ Hadoop, Java,และซอฟต์แวร์อื่น ๆ ได้รับการติดตั้ง (ในบทช่วยสอนของเราเราได้สร้างไดเรกทอรี Pig ในผู้ใช้ชื่อ Hadoop)

$ mkdir Pig

ขั้นตอนที่ 2

แตกไฟล์ tar ที่ดาวน์โหลดมาดังแสดงด้านล่าง

$ cd Downloads/ 
$ tar zxvf pig-0.15.0-src.tar.gz $ tar zxvf pig-0.15.0.tar.gz

ขั้นตอนที่ 3

ย้ายเนื้อหาของ pig-0.15.0-src.tar.gz ไฟล์ไปยังไฟล์ Pig ไดเร็กทอรีที่สร้างขึ้นก่อนหน้านี้ตามที่แสดงด้านล่าง

$ mv pig-0.15.0-src.tar.gz/* /home/Hadoop/Pig/

กำหนดค่า Apache Pig

หลังจากติดตั้ง Apache Pig เราต้องกำหนดค่า ในการกำหนดค่าเราต้องแก้ไขสองไฟล์ -bashrc and pig.properties.

ไฟล์. bashrc

ใน .bashrc ไฟล์กำหนดตัวแปรต่อไปนี้ -

• PIG_HOME ไปยังโฟลเดอร์การติดตั้งของ Apache Pig

• PATH ตัวแปรสภาพแวดล้อมไปยังโฟลเดอร์ bin และ

• PIG_CLASSPATH ตัวแปรสภาพแวดล้อมไปยังโฟลเดอร์ etc (configuration) ของการติดตั้ง Hadoop ของคุณ (ไดเร็กทอรีที่มีไฟล์ core-site.xml, hdfs-site.xml และ mapred-site.xml)

export PIG_HOME = /home/Hadoop/Pig
export PATH  = $PATH:/home/Hadoop/pig/bin
export PIG_CLASSPATH = $HADOOP_HOME/conf

pig.properties ไฟล์

ใน conf โฟลเดอร์ของ Pig เรามีไฟล์ชื่อ pig.properties. ในไฟล์ pig.properties คุณสามารถตั้งค่าพารามิเตอร์ต่างๆได้ตามที่ระบุด้านล่าง

pig -h properties

รองรับคุณสมบัติต่อไปนี้ -

Logging: verbose = true|false; default is false. This property is the same as -v
       switch brief=true|false; default is false. This property is the same 
       as -b switch debug=OFF|ERROR|WARN|INFO|DEBUG; default is INFO.             
       This property is the same as -d switch aggregate.warning = true|false; default is true. 
       If true, prints count of warnings of each type rather than logging each warning.		 
		 
Performance tuning: pig.cachedbag.memusage=<mem fraction>; default is 0.2 (20% of all memory).
       Note that this memory is shared across all large bags used by the application.         
       pig.skewedjoin.reduce.memusagea=<mem fraction>; default is 0.3 (30% of all memory).
       Specifies the fraction of heap available for the reducer to perform the join.
       pig.exec.nocombiner = true|false; default is false.
           Only disable combiner as a temporary workaround for problems.         
       opt.multiquery = true|false; multiquery is on by default.
           Only disable multiquery as a temporary workaround for problems.
       opt.fetch=true|false; fetch is on by default.
           Scripts containing Filter, Foreach, Limit, Stream, and Union can be dumped without MR jobs.         
       pig.tmpfilecompression = true|false; compression is off by default.             
           Determines whether output of intermediate jobs is compressed.         
       pig.tmpfilecompression.codec = lzo|gzip; default is gzip.
           Used in conjunction with pig.tmpfilecompression. Defines compression type.         
       pig.noSplitCombination = true|false. Split combination is on by default.
           Determines if multiple small files are combined into a single map.         
			  
       pig.exec.mapPartAgg = true|false. Default is false.             
           Determines if partial aggregation is done within map phase, before records are sent to combiner.         
       pig.exec.mapPartAgg.minReduction=<min aggregation factor>. Default is 10.             
           If the in-map partial aggregation does not reduce the output num records by this factor, it gets disabled.
			  
Miscellaneous: exectype = mapreduce|tez|local; default is mapreduce. This property is the same as -x switch
       pig.additional.jars.uris=<comma seperated list of jars>. Used in place of register command.
       udf.import.list=<comma seperated list of imports>. Used to avoid package names in UDF.
       stop.on.failure = true|false; default is false. Set to true to terminate on the first error.         
       pig.datetime.default.tz=<UTC time offset>. e.g. +08:00. Default is the default timezone of the host.
           Determines the timezone used to handle datetime datatype and UDFs.
Additionally, any Hadoop property can be specified.

ตรวจสอบการติดตั้ง

ตรวจสอบการติดตั้ง Apache Pig โดยพิมพ์คำสั่ง version หากการติดตั้งสำเร็จคุณจะได้รับ Apache Pig เวอร์ชันดังที่แสดงด้านล่าง

$ pig –version 
 
Apache Pig version 0.15.0 (r1682971)  
compiled Jun 01 2015, 11:44:35

ในบทที่แล้วเราได้อธิบายวิธีการติดตั้ง Apache Pig ในบทนี้เราจะพูดถึงวิธีการรัน Apache Pig

โหมดการดำเนินการ Apache Pig

คุณสามารถเรียกใช้ Apache Pig ได้ในสองโหมดคือ Local Mode และ HDFS mode.

โหมดท้องถิ่น

ในโหมดนี้ไฟล์ทั้งหมดจะถูกติดตั้งและเรียกใช้จากโลคัลโฮสต์และระบบไฟล์ในเครื่องของคุณ ไม่จำเป็นต้องมี Hadoop หรือ HDFS โดยทั่วไปโหมดนี้จะใช้เพื่อการทดสอบ

โหมด MapReduce

โหมด MapReduce คือที่ที่เราโหลดหรือประมวลผลข้อมูลที่มีอยู่ใน Hadoop File System (HDFS) โดยใช้ Apache Pig ในโหมดนี้เมื่อใดก็ตามที่เราเรียกใช้คำสั่ง Pig Latin เพื่อประมวลผลข้อมูลงาน MapReduce จะถูกเรียกใช้ในส่วนหลังเพื่อดำเนินการเฉพาะกับข้อมูลที่มีอยู่ใน HDFS

กลไกการดำเนินการ Apache Pig

สคริปต์ Apache Pig สามารถดำเนินการได้สามวิธี ได้แก่ โหมดโต้ตอบโหมดแบทช์และโหมดฝังตัว

• Interactive Mode(Grunt shell) - คุณสามารถเรียกใช้ Apache Pig ในโหมดโต้ตอบได้โดยใช้ Grunt shell ในเชลล์นี้คุณสามารถป้อนคำสั่ง Pig Latin และรับเอาต์พุต (โดยใช้ตัวดำเนินการถ่ายโอนข้อมูล)

• Batch Mode (Script) - คุณสามารถเรียกใช้ Apache Pig ในโหมด Batch ได้โดยเขียนสคริปต์ Pig Latin ในไฟล์เดียวด้วย .pig ส่วนขยาย.

• Embedded Mode (UDF) - Apache Pig ให้การกำหนดฟังก์ชันของเราเอง (Uเซอร์ Defined Functions) ในภาษาโปรแกรมเช่น Java และใช้ในสคริปต์ของเรา

เรียกใช้ Grunt Shell

คุณสามารถเรียกใช้ Grunt shell ในโหมดที่ต้องการ (local / MapReduce) โดยใช้ไฟล์ −x ตามที่แสดงด้านล่าง

โหมดท้องถิ่น	โหมด MapReduce
Command − $ ./pig –x ในพื้นที่	Command − $ ./pig -x mapreduce
Output -	Output -

คำสั่งอย่างใดอย่างหนึ่งเหล่านี้ให้พรอมต์เชลล์ Grunt ดังที่แสดงด้านล่าง

grunt>

คุณสามารถออกจากกระสุน Grunt โดยใช้ ‘ctrl + d’.

หลังจากเรียกใช้เชลล์ Grunt คุณสามารถเรียกใช้สคริปต์ Pig ได้โดยป้อนคำสั่ง Pig Latin ในนั้นโดยตรง

grunt> customers = LOAD 'customers.txt' USING PigStorage(',');

ดำเนินการ Apache Pig ในโหมดแบทช์

คุณสามารถเขียนสคริปต์ Pig Latin ทั้งหมดในไฟล์และดำเนินการโดยใช้ไฟล์ –x command. สมมติว่าเรามีสคริปต์ Pig ในไฟล์ชื่อsample_script.pig ดังแสดงด้านล่าง

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING
   PigStorage(',') as (id:int,name:chararray,city:chararray);
  
Dump student;

ตอนนี้คุณสามารถเรียกใช้สคริปต์ในไฟล์ด้านบนดังที่แสดงด้านล่าง

โหมดท้องถิ่น	โหมด MapReduce
$ หมู -x ท้องถิ่น Sample_script.pig	$ หมู -x mapreduce Sample_script.pig

Note - เราจะพูดถึงรายละเอียดเกี่ยวกับวิธีเรียกใช้สคริปต์ Pig Bach mode และใน embedded mode ในบทต่อ ๆ ไป

หลังจากเรียกใช้เชลล์ Grunt คุณสามารถรันสคริปต์ Pig ของคุณในเชลล์ได้ นอกจากนั้นยังมีคำสั่งเชลล์และยูทิลิตี้ที่มีประโยชน์บางอย่างที่จัดเตรียมโดย Grunt shell บทนี้อธิบายคำสั่งเชลล์และยูทิลิตี้ที่จัดเตรียมโดย Grunt shell

Note - ในบางส่วนของบทนี้คำสั่งเช่น Load และ Storeใช้ อ้างถึงบทต่างๆเพื่อรับข้อมูลโดยละเอียด

คำสั่งเชลล์

เปลือก Grunt ของ Apache Pig ส่วนใหญ่จะใช้ในการเขียนสคริปต์ Pig Latin ก่อนหน้านั้นเราสามารถเรียกใช้คำสั่งเชลล์โดยใช้sh และ fs.

คำสั่ง sh

การใช้ shคำสั่งเราสามารถเรียกใช้คำสั่งเชลล์ใด ๆ จาก Grunt shell การใช้sh คำสั่งจาก Grunt shell เราไม่สามารถรันคำสั่งที่เป็นส่วนหนึ่งของสภาพแวดล้อมเชลล์ (ex - ซีดี)

Syntax

ด้านล่างนี้คือไวยากรณ์ของ sh คำสั่ง

grunt> sh shell command parameters

Example

เราสามารถเรียกใช้ไฟล์ ls คำสั่งของ Linux shell จาก Grunt shell โดยใช้ shตามที่แสดงด้านล่าง ในตัวอย่างนี้จะแสดงรายการไฟล์ในไฟล์/pig/bin/ ไดเรกทอรี

grunt> sh ls
   
pig 
pig_1444799121955.log 
pig.cmd 
pig.py

คำสั่ง fs

ใช้ fs คำสั่งเราสามารถเรียกใช้คำสั่ง FsShell ใด ๆ จาก Grunt shell

Syntax

ด้านล่างนี้คือไวยากรณ์ของ fs คำสั่ง

grunt> sh File System command parameters

Example

เราสามารถเรียกใช้คำสั่ง ls ของ HDFS จาก Grunt shell โดยใช้คำสั่ง fs ในตัวอย่างต่อไปนี้จะแสดงรายการไฟล์ในไดเร็กทอรีรากของ HDFS

grunt> fs –ls
  
Found 3 items
drwxrwxrwx   - Hadoop supergroup          0 2015-09-08 14:13 Hbase
drwxr-xr-x   - Hadoop supergroup          0 2015-09-09 14:52 seqgen_data
drwxr-xr-x   - Hadoop supergroup          0 2015-09-08 11:30 twitter_data

ในทำนองเดียวกันเราสามารถเรียกใช้คำสั่งเชลล์ระบบไฟล์อื่น ๆ ทั้งหมดจาก Grunt shell โดยใช้ fs คำสั่ง

คำสั่งยูทิลิตี้

Grunt shell จัดเตรียมชุดคำสั่งยูทิลิตี้ สิ่งเหล่านี้รวมถึงคำสั่งยูทิลิตี้เช่นclear, help, history, quit, และ set; และคำสั่งต่างๆเช่นexec, kill, และ runเพื่อควบคุม Pig จากกระสุน Grunt ด้านล่างนี้เป็นคำอธิบายของคำสั่งยูทิลิตี้ที่จัดเตรียมโดย Grunt shell

ล้างคำสั่ง

clear คำสั่งใช้เพื่อล้างหน้าจอของ Grunt shell

Syntax

คุณสามารถล้างหน้าจอของกระสุนคำรามโดยใช้ไฟล์ clear คำสั่งดังที่แสดงด้านล่าง

grunt> clear

ช่วยคำสั่ง

help คำสั่งให้รายการคำสั่ง Pig หรือคุณสมบัติ Pig

Usage

คุณสามารถรับรายการคำสั่ง Pig โดยใช้ไฟล์ help คำสั่งดังที่แสดงด้านล่าง

grunt> help

Commands: <pig latin statement>; - See the PigLatin manual for details:
http://hadoop.apache.org/pig
  
File system commands:fs <fs arguments> - Equivalent to Hadoop dfs  command:
http://hadoop.apache.org/common/docs/current/hdfs_shell.html
	 
Diagnostic Commands:describe <alias>[::<alias] - Show the schema for the alias.
Inner aliases can be described as A::B.
    explain [-script <pigscript>] [-out <path>] [-brief] [-dot|-xml] 
       [-param <param_name>=<pCram_value>]
       [-param_file <file_name>] [<alias>] - 
       Show the execution plan to compute the alias or for entire script.
       -script - Explain the entire script.
       -out - Store the output into directory rather than print to stdout.
       -brief - Don't expand nested plans (presenting a smaller graph for overview).
       -dot - Generate the output in .dot format. Default is text format.
       -xml - Generate the output in .xml format. Default is text format.
       -param <param_name - See parameter substitution for details.
       -param_file <file_name> - See parameter substitution for details.
       alias - Alias to explain.
       dump <alias> - Compute the alias and writes the results to stdout.

Utility Commands: exec [-param <param_name>=param_value] [-param_file <file_name>] <script> -
       Execute the script with access to grunt environment including aliases.
       -param <param_name - See parameter substitution for details.
       -param_file <file_name> - See parameter substitution for details.
       script - Script to be executed.
    run [-param <param_name>=param_value] [-param_file <file_name>] <script> -
       Execute the script with access to grunt environment.
		 -param <param_name - See parameter substitution for details.         
       -param_file <file_name> - See parameter substitution for details.
       script - Script to be executed.
    sh  <shell command> - Invoke a shell command.
    kill <job_id> - Kill the hadoop job specified by the hadoop job id.
    set <key> <value> - Provide execution parameters to Pig. Keys and values are case sensitive.
       The following keys are supported:
       default_parallel - Script-level reduce parallelism. Basic input size heuristics used 
       by default.
       debug - Set debug on or off. Default is off.
       job.name - Single-quoted name for jobs. Default is PigLatin:<script name>     
       job.priority - Priority for jobs. Values: very_low, low, normal, high, very_high.
       Default is normal stream.skippath - String that contains the path.
       This is used by streaming any hadoop property.
    help - Display this message.
    history [-n] - Display the list statements in cache.
       -n Hide line numbers.
    quit - Quit the grunt shell.

คำสั่งประวัติศาสตร์

คำสั่งนี้แสดงรายการของคำสั่งที่เรียกใช้ / ใช้จนถึงตอนนี้ตั้งแต่เรียก Grunt sell

Usage

สมมติว่าเราได้ดำเนินการสามคำสั่งตั้งแต่เปิด Grunt shell

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',');
 
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',');
 
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',');

จากนั้นใช้ไฟล์ history คำสั่งจะสร้างผลลัพธ์ต่อไปนี้

grunt> history

customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(','); 
  
orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',');
   
student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',');

ตั้งค่า Command

set คำสั่งใช้เพื่อแสดง / กำหนดค่าให้กับคีย์ที่ใช้ใน Pig

Usage

เมื่อใช้คำสั่งนี้คุณสามารถตั้งค่าให้กับคีย์ต่อไปนี้

สำคัญ	คำอธิบายและค่าต่างๆ
default_parallel	คุณสามารถกำหนดจำนวนตัวลดสำหรับงานแผนที่ได้โดยส่งจำนวนเต็มใด ๆ เป็นค่าไปยังคีย์นี้
debug	คุณสามารถปิดหรือเปิดการดีบัก freature ใน Pig ได้โดยส่งต่อไปยังคีย์นี้
job.name	คุณสามารถตั้งชื่องานเป็นงานที่ต้องการได้โดยส่งค่าสตริงไปยังคีย์นี้
job.priority	คุณสามารถกำหนดลำดับความสำคัญของงานให้กับงานได้โดยส่งค่าใดค่าหนึ่งต่อไปนี้ไปยังคีย์นี้ - very_low low normal high very_high
stream.skippath	สำหรับการสตรีมคุณสามารถกำหนดเส้นทางจากจุดที่จะไม่ถ่ายโอนข้อมูลโดยส่งเส้นทางที่ต้องการในรูปแบบสตริงไปยังคีย์นี้

ออกจากคำสั่ง

คุณสามารถออกจากเชลล์ Grunt โดยใช้คำสั่งนี้

Usage

ออกจากเชลล์ Grunt ดังที่แสดงด้านล่าง

grunt> quit

ตอนนี้เรามาดูคำสั่งที่ใช้ควบคุม Apache Pig จาก Grunt shell

คำสั่ง exec

ใช้ exec คำสั่งเราสามารถรันสคริปต์ Pig จาก Grunt shell

Syntax

ให้ด้านล่างนี้เป็นไวยากรณ์ของคำสั่งยูทิลิตี้ exec.

grunt> exec [–param param_name = param_value] [–param_file file_name] [script]

Example

ให้เราถือว่ามีไฟล์ชื่อ student.txt ใน /pig_data/ ไดเร็กทอรีของ HDFS ที่มีเนื้อหาต่อไปนี้

Student.txt

001,Rajiv,Hyderabad
002,siddarth,Kolkata
003,Rajesh,Delhi

และสมมติว่าเรามีไฟล์สคริปต์ชื่อ sample_script.pig ใน /pig_data/ ไดเร็กทอรีของ HDFS ที่มีเนื้อหาต่อไปนี้

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',') 
   as (id:int,name:chararray,city:chararray);
  
Dump student;

ตอนนี้ให้เรารันสคริปต์ด้านบนจาก Grunt shell โดยใช้ไฟล์ exec คำสั่งดังที่แสดงด้านล่าง

grunt> exec /sample_script.pig

Output

exec คำสั่งเรียกใช้สคริปต์ในไฟล์ sample_script.pig. ตามที่กำหนดไว้ในสคริปต์จะโหลดไฟล์student.txt ไฟล์ลงใน Pig และให้ผลลัพธ์ของตัวดำเนินการถ่ายโอนข้อมูลที่แสดงเนื้อหาต่อไปนี้

(1,Rajiv,Hyderabad)
(2,siddarth,Kolkata)
(3,Rajesh,Delhi)

ฆ่าคำสั่ง

คุณสามารถฆ่างานจากเชลล์ Grunt โดยใช้คำสั่งนี้

Syntax

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ kill คำสั่ง

grunt> kill JobId

Example

สมมติว่ามีงาน Pig ที่กำลังทำงานอยู่ซึ่งมี id Id_0055คุณสามารถฆ่ามันจากกระสุน Grunt โดยใช้ kill คำสั่งดังที่แสดงด้านล่าง

grunt> kill Id_0055

เรียกใช้คำสั่ง

คุณสามารถเรียกใช้สคริปต์ Pig จากเชลล์ Grunt โดยใช้ไฟล์ run คำสั่ง

Syntax

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ run คำสั่ง

grunt> run [–param param_name = param_value] [–param_file file_name] script

Example

ให้เราถือว่ามีไฟล์ชื่อ student.txt ใน /pig_data/ ไดเร็กทอรีของ HDFS ที่มีเนื้อหาต่อไปนี้

Student.txt

001,Rajiv,Hyderabad
002,siddarth,Kolkata
003,Rajesh,Delhi

และสมมติว่าเรามีไฟล์สคริปต์ชื่อ sample_script.pig ในระบบไฟล์โลคัลที่มีเนื้อหาต่อไปนี้

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING
   PigStorage(',') as (id:int,name:chararray,city:chararray);

ตอนนี้ให้เรารันสคริปต์ด้านบนจาก Grunt shell โดยใช้คำสั่ง run ดังที่แสดงด้านล่าง

grunt> run /sample_script.pig

คุณสามารถดูผลลัพธ์ของสคริปต์โดยใช้ไฟล์ Dump operator ดังแสดงด้านล่าง

grunt> Dump;

(1,Rajiv,Hyderabad)
(2,siddarth,Kolkata)
(3,Rajesh,Delhi)

Note - ความแตกต่างระหว่าง exec และ run คำสั่งคือถ้าเราใช้ runคำสั่งจากสคริปต์มีอยู่ในประวัติคำสั่ง

Pig Latin เป็นภาษาที่ใช้ในการวิเคราะห์ข้อมูลใน Hadoop โดยใช้ Apache Pig ในบทนี้เราจะพูดถึงพื้นฐานของ Pig Latin เช่นคำสั่ง Pig Latin ประเภทข้อมูลตัวดำเนินการทั่วไปและเชิงสัมพันธ์และ Pig Latin UDF

Pig Latin - แบบจำลองข้อมูล

ตามที่กล่าวไว้ในบทก่อนหน้าโมเดลข้อมูลของ Pig จะซ้อนกันอย่างสมบูรณ์ กRelationเป็นโครงสร้างด้านนอกสุดของโมเดลข้อมูล Pig Latin และก็คือbag ที่ไหน -

• กระเป๋าเป็นของสะสมของสิ่งทอ
• ทูเปิลคือชุดฟิลด์ที่เรียงลำดับ
• เขตข้อมูลคือส่วนหนึ่งของข้อมูล

Pig Latin - Statemets

ขณะประมวลผลข้อมูลโดยใช้ Pig Latin statements เป็นโครงสร้างพื้นฐาน

• ข้อความเหล่านี้ใช้ได้กับ relations. รวมถึงexpressions และ schemas.

• ทุกคำสั่งลงท้ายด้วยอัฒภาค (;)

• เราจะดำเนินการต่างๆโดยใช้ตัวดำเนินการที่จัดทำโดย Pig Latin ผ่านแถลงการณ์

• ยกเว้น LOAD และ STORE ในขณะที่ดำเนินการอื่น ๆ คำสั่ง Pig Latin จะใช้ความสัมพันธ์เป็นอินพุตและสร้างความสัมพันธ์อื่นเป็นเอาต์พุต

• ทันทีที่คุณป้อนไฟล์ Loadคำสั่งในเชลล์ Grunt การตรวจสอบความหมายจะดำเนินการ หากต้องการดูเนื้อหาของสคีมาคุณต้องใช้ไฟล์Dumpตัวดำเนินการ หลังจากดำเนินการdump การดำเนินการงาน MapReduce สำหรับการโหลดข้อมูลลงในระบบไฟล์จะดำเนินการ

ตัวอย่าง

ด้านล่างเป็นคำสั่ง Pig Latin ซึ่งจะโหลดข้อมูลไปยัง Apache Pig

grunt> Student_data = LOAD 'student_data.txt' USING PigStorage(',')as 
   ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

Pig Latin - ประเภทข้อมูล

ตารางด้านล่างอธิบายประเภทข้อมูล Pig Latin

SN	ประเภทข้อมูล	คำอธิบายและตัวอย่าง
1	int	แทนจำนวนเต็ม 32 บิตที่ลงนาม Example : 8
2	ยาว	แทนจำนวนเต็ม 64 บิตที่ลงนาม Example : 5 ล
3	ลอย	แสดงจุดลอยตัว 32 บิตที่ลงนาม Example : 5.5F
4	สองเท่า	แสดงถึงทศนิยม 64 บิต Example : 10.5
5	chararray	แสดงอาร์เรย์อักขระ (สตริง) ในรูปแบบ Unicode UTF-8 Example : 'บทเรียนชี้'
6	Bytearray	แสดงอาร์เรย์ไบต์ (หยด)
7	บูลีน	แสดงค่าบูลีน Example : ถูกผิด.
8	วันเวลา	แสดงวันที่ - เวลา Example : 1970-01-01T00: 00: 00.000 + 00: 00 น
9	Biginteger	แสดง Java BigInteger Example : 60708090709
10	ทศนิยมใหญ่	แสดง Java BigDecimal Example : 185.98376256272893883
ประเภทที่ซับซ้อน
11	ทูเพิล	ทูเปิลคือชุดฟิลด์ที่เรียงลำดับ Example : (ราชา, 30)
12	ถุง	กระเป๋าเป็นของสะสมของสิ่งทอ Example : {(raju, 30), (โมฮัมหมัด, 45)}
13	แผนที่	แผนที่คือชุดของคู่คีย์ - ค่า Example : ['name' # 'Raju', 'age' # 30]

ค่าว่าง

ค่าสำหรับประเภทข้อมูลทั้งหมดข้างต้นสามารถเป็น NULL Apache Pig ปฏิบัติต่อค่า null ในลักษณะเดียวกับ SQL

ค่าว่างอาจเป็นค่าที่ไม่รู้จักหรือค่าที่ไม่มีอยู่จริง ใช้เป็นตัวยึดสำหรับค่าทางเลือก ค่าว่างเหล่านี้สามารถเกิดขึ้นได้ตามธรรมชาติหรืออาจเป็นผลมาจากการดำเนินการ

Pig Latin - ตัวดำเนินการทางคณิตศาสตร์

ตารางต่อไปนี้อธิบายตัวดำเนินการทางคณิตศาสตร์ของ Pig Latin สมมติว่า a = 10 และ b = 20

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
+	Addition - เพิ่มค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ	a + b จะให้ 30
-	Subtraction - ลบตัวถูกดำเนินการทางขวามือออกจากตัวถูกดำเนินการด้านซ้าย	a - b จะให้ −10
*	Multiplication - คูณค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ	a * b จะให้ 200
/	Division - แบ่งตัวถูกดำเนินการทางซ้ายด้วยตัวถูกดำเนินการทางขวามือ	b / a จะให้ 2
%	Modulus - แบ่งตัวถูกดำเนินการทางซ้ายด้วยตัวถูกดำเนินการทางขวามือและส่งคืนส่วนที่เหลือ	b% a จะให้ 0
เหรอ? :	Bincond- ประเมินตัวดำเนินการบูลีน มีสามตัวถูกดำเนินการดังที่แสดงด้านล่าง ตัวแปร x = (นิพจน์)? value1 ถ้าเป็นจริง :value2 ถ้าเป็นเท็จ	b = (a == 1)? 20: 30; ถ้า a = 1 ค่าของ b คือ 20 ถ้า a! = 1 ค่าของ b คือ 30
กรณี เมื่อไหร่ แล้ว สิ้นสุดอีกครั้ง	Case - ตัวดำเนินการเคสเทียบเท่ากับตัวดำเนินการ bincond ที่ซ้อนกัน	กรณี f2% 2 เมื่อ 0 แล้ว 'แม้' เมื่อ 1 แล้ว 'คี่' สิ้นสุด

Pig Latin - ตัวดำเนินการเปรียบเทียบ

ตารางต่อไปนี้อธิบายตัวดำเนินการเปรียบเทียบของ Pig Latin

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
==	Equal- ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(a = b) ไม่เป็นความจริง
! =	Not Equal- ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง	(a! = b) เป็นจริง
>	Greater than- ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขนั้นจะกลายเป็นจริง	(a> b) ไม่เป็นความจริง
<	Less than- ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขนั้นจะกลายเป็นจริง	(a <b) เป็นจริง
> =	Greater than or equal to- ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขนั้นจะกลายเป็นจริง	(a> = b) ไม่เป็นความจริง
<=	Less than or equal to- ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขนั้นจะกลายเป็นจริง	(a <= b) เป็นจริง
การแข่งขัน	Pattern matching - ตรวจสอบว่าสตริงทางด้านซ้ายมือตรงกับค่าคงที่ทางด้านขวามือหรือไม่	f1 ตรงกับ '. * บทช่วยสอน. *'

Pig Latin - ประเภทช่างก่อสร้าง

ตารางต่อไปนี้อธิบายตัวดำเนินการก่อสร้าง Type ของ Pig Latin

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
()	Tuple constructor operator - ตัวดำเนินการนี้ใช้เพื่อสร้างทูเพิล	(ราจู 30)
{}	Bag constructor operator - ตัวดำเนินการนี้ใช้ในการสร้างกระเป๋า	{(ราจู 30), (โมฮัมหมัด, 45)}
[]	Map constructor operator - ตัวดำเนินการนี้ใช้เพื่อสร้างทูเพิล	[ชื่อ # ราชาอายุ # 30]

Pig Latin - การดำเนินการเชิงสัมพันธ์

ตารางต่อไปนี้อธิบายตัวดำเนินการเชิงสัมพันธ์ของ Pig Latin

ตัวดำเนินการ	คำอธิบาย
Loading and Storing
โหลด	ในการโหลดข้อมูลจากระบบไฟล์ (local / HDFS) ลงในรีเลชัน
เก็บ	เพื่อบันทึกความสัมพันธ์กับระบบไฟล์ (โลคัล / HDFS)
การกรอง
กรอง	เพื่อลบแถวที่ไม่ต้องการออกจากความสัมพันธ์
แตกต่าง	เพื่อลบแถวที่ซ้ำกันออกจากความสัมพันธ์
FOREACH สร้าง	เพื่อสร้างการแปลงข้อมูลตามคอลัมน์ของข้อมูล
กระแส	เพื่อแปลงความสัมพันธ์โดยใช้โปรแกรมภายนอก
การจัดกลุ่มและการเข้าร่วม
เข้าร่วม	เพื่อเข้าร่วมความสัมพันธ์ตั้งแต่สองคนขึ้นไป
COGROUP	เพื่อจัดกลุ่มข้อมูลในสองความสัมพันธ์ขึ้นไป
กลุ่ม	เพื่อจัดกลุ่มข้อมูลในความสัมพันธ์เดียว
ข้าม	เพื่อสร้างผลคูณไขว้ของความสัมพันธ์ตั้งแต่สองตัวขึ้นไป
การเรียงลำดับ
ใบสั่ง	ในการจัดเรียงความสัมพันธ์ตามลำดับที่เรียงตามฟิลด์อย่างน้อยหนึ่งฟิลด์ (จากน้อยไปมากหรือมากไปหาน้อย)
LIMIT	เพื่อรับจำนวนสิ่งที่ จำกัด จากความสัมพันธ์
การรวมและการแยก
ยูเนี่ยน	เพื่อรวมความสัมพันธ์ตั้งแต่สองความสัมพันธ์ขึ้นไปเป็นความสัมพันธ์เดียว
แยก	เพื่อแบ่งความสัมพันธ์เดียวออกเป็นสองความสัมพันธ์หรือมากกว่า
ตัวดำเนินการวินิจฉัย
DUMP	เพื่อพิมพ์เนื้อหาของความสัมพันธ์บนคอนโซล
อธิบาย	เพื่ออธิบายสคีมาของความสัมพันธ์
อธิบาย	เพื่อดูแผนการดำเนินการเชิงตรรกะทางกายภาพหรือ MapReduce เพื่อคำนวณความสัมพันธ์
ภาพลวงตา	เพื่อดูการดำเนินการทีละขั้นตอนของชุดคำสั่ง

โดยทั่วไปแล้ว Apache Pig จะทำงานบน Hadoop เป็นเครื่องมือวิเคราะห์ที่วิเคราะห์ชุดข้อมูลขนาดใหญ่ที่มีอยู่ในไฟล์Hadoop File System. ในการวิเคราะห์ข้อมูลโดยใช้ Apache Pig เราต้องโหลดข้อมูลลงใน Apache Pig ก่อน บทนี้จะอธิบายวิธีการโหลดข้อมูลไปยัง Apache Pig จาก HDFS

กำลังเตรียม HDFS

ในโหมด MapReduce Pig จะอ่าน (โหลด) ข้อมูลจาก HDFS และเก็บผลลัพธ์ไว้ใน HDFS ดังนั้นให้เราเริ่ม HDFS และสร้างข้อมูลตัวอย่างต่อไปนี้ใน HDFS

รหัสนักศึกษา	ชื่อจริง	นามสกุล	โทรศัพท์	เมือง
001	ราจีฟ	เรดดี้	9848022337	ไฮเดอราบาด
002	Siddarth	Battacharya	9848022338	กัลกัตตา
003	Rajesh	คันนา	9848022339	เดลี
004	พรีธี	Agarwal	9848022330	ปูน
005	ทรัพฐี	โมฮันธี	9848022336	ภุวาเนศวร
006	อรชนา	มิชรา	9848022335	เจนไน

ชุดข้อมูลด้านบนประกอบด้วยรายละเอียดส่วนบุคคลเช่นรหัสชื่อนามสกุลหมายเลขโทรศัพท์และเมืองของนักเรียนหกคน

ขั้นตอนที่ 1: การตรวจสอบ Hadoop

ก่อนอื่นตรวจสอบการติดตั้งโดยใช้คำสั่ง Hadoop version ดังที่แสดงด้านล่าง

$ hadoop version

หากระบบของคุณมี Hadoop และหากคุณตั้งค่าตัวแปร PATH คุณจะได้ผลลัพธ์ต่อไปนี้ -

Hadoop 2.6.0 
Subversion https://git-wip-us.apache.org/repos/asf/hadoop.git -r 
e3496499ecb8d220fba99dc5ed4c99c8f9e33bb1 
Compiled by jenkins on 2014-11-13T21:10Z 
Compiled with protoc 2.5.0 
From source with checksum 18e43357c8f927c0695f1e9522859d6a 
This command was run using /home/Hadoop/hadoop/share/hadoop/common/hadoop
common-2.6.0.jar

ขั้นตอนที่ 2: การเริ่ม HDFS

เรียกดูไฟล์ sbin ไดเร็กทอรีของ Hadoop และเริ่มต้น yarn และ Hadoop dfs (ระบบไฟล์แบบกระจาย) ดังที่แสดงด้านล่าง

cd /$Hadoop_Home/sbin/ 
$ start-dfs.sh 
localhost: starting namenode, logging to /home/Hadoop/hadoop/logs/hadoopHadoop-namenode-localhost.localdomain.out 
localhost: starting datanode, logging to /home/Hadoop/hadoop/logs/hadoopHadoop-datanode-localhost.localdomain.out 
Starting secondary namenodes [0.0.0.0] 
starting secondarynamenode, logging to /home/Hadoop/hadoop/logs/hadoop-Hadoopsecondarynamenode-localhost.localdomain.out
 
$ start-yarn.sh 
starting yarn daemons 
starting resourcemanager, logging to /home/Hadoop/hadoop/logs/yarn-Hadoopresourcemanager-localhost.localdomain.out 
localhost: starting nodemanager, logging to /home/Hadoop/hadoop/logs/yarnHadoop-nodemanager-localhost.localdomain.out

ขั้นตอนที่ 3: สร้างไดเรกทอรีใน HDFS

ใน Hadoop DFS คุณสามารถสร้างไดเร็กทอรีโดยใช้คำสั่ง mkdir. สร้างไดเร็กทอรีใหม่ใน HDFS ด้วยชื่อPig_Data ในเส้นทางที่ต้องการดังแสดงด้านล่าง

$cd /$Hadoop_Home/bin/ 
$ hdfs dfs -mkdir hdfs://localhost:9000/Pig_Data

ขั้นตอนที่ 4: การวางข้อมูลใน HDFS

ไฟล์อินพุตของ Pig ประกอบด้วยทูเพิล / เร็กคอร์ดแต่ละรายการในแต่ละบรรทัด และเอนทิตีของเร็กคอร์ดถูกคั่นด้วยตัวคั่น (ในตัวอย่างของเราเราใช้“,”).

ในระบบไฟล์โลคัลสร้างไฟล์อินพุต student_data.txt มีข้อมูลตามที่แสดงด้านล่าง

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

ตอนนี้ย้ายไฟล์จากระบบไฟล์ในเครื่องไปยัง HDFS โดยใช้ไฟล์ putคำสั่งดังที่แสดงด้านล่าง (คุณสามารถใช้ได้copyFromLocal คำสั่งเช่นกัน)

$ cd $HADOOP_HOME/bin $ hdfs dfs -put /home/Hadoop/Pig/Pig_Data/student_data.txt dfs://localhost:9000/pig_data/

กำลังตรวจสอบไฟล์

คุณสามารถใช้ไฟล์ cat คำสั่งเพื่อตรวจสอบว่าไฟล์ถูกย้ายไปที่ HDFS หรือไม่ตามที่แสดงด้านล่าง

$ cd $HADOOP_HOME/bin
$ hdfs dfs -cat hdfs://localhost:9000/pig_data/student_data.txt

เอาต์พุต

คุณสามารถดูเนื้อหาของไฟล์ดังที่แสดงด้านล่าง

15/10/01 12:16:55 WARN util.NativeCodeLoader: Unable to load native-hadoop
library for your platform... using builtin-java classes where applicable
  
001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai

ตัวดำเนินการโหลด

คุณสามารถโหลดข้อมูลลงใน Apache Pig จากระบบไฟล์ (HDFS / Local) โดยใช้ไฟล์ LOAD ผู้ดำเนินการของ Pig Latin.

ไวยากรณ์

คำสั่งโหลดประกอบด้วยสองส่วนหารด้วยตัวดำเนินการ“ =” ทางด้านซ้ายมือเราต้องระบุชื่อของความสัมพันธ์where เราต้องการจัดเก็บข้อมูลและทางด้านขวามือเราต้องกำหนด howเราจัดเก็บข้อมูล ด้านล่างนี้เป็นไวยากรณ์ของไฟล์Load ตัวดำเนินการ

Relation_name = LOAD 'Input file path' USING function as schema;

ที่ไหน

• relation_name - เราต้องพูดถึงความสัมพันธ์ที่เราต้องการจัดเก็บข้อมูล

• Input file path- เราต้องพูดถึงไดเร็กทอรี HDFS ที่เก็บไฟล์ (ในโหมด MapReduce)

• function - เราต้องเลือกฟังก์ชั่นจากชุดฟังก์ชั่นโหลดที่จัดทำโดย Apache Pig (BinStorage, JsonLoader, PigStorage, TextLoader).

• Schema- เราต้องกำหนดสคีมาของข้อมูล เราสามารถกำหนดสคีมาที่ต้องการได้ดังนี้ -

(column1 : data type, column2 : data type, column3 : data type);

Note- เราโหลดข้อมูลโดยไม่ระบุสคีมา ในกรณีนี้คอลัมน์จะถูกระบุเป็น $ 01, $ 02 ฯลฯ ... (ตรวจสอบ)

ตัวอย่าง

ตัวอย่างเช่นให้เราโหลดข้อมูลใน student_data.txt ในหมูภายใต้สคีมาชื่อ Student ใช้ LOAD คำสั่ง

เริ่มต้น Pig Grunt Shell

ก่อนอื่นเปิดเทอร์มินัล Linux เริ่มเชลล์ Pig Grunt ในโหมด MapReduce ดังที่แสดงด้านล่าง

$ Pig –x mapreduce

มันจะเริ่มเชลล์ Pig Grunt ดังที่แสดงด้านล่าง

15/10/01 12:33:37 INFO pig.ExecTypeProvider: Trying ExecType : LOCAL
15/10/01 12:33:37 INFO pig.ExecTypeProvider: Trying ExecType : MAPREDUCE
15/10/01 12:33:37 INFO pig.ExecTypeProvider: Picked MAPREDUCE as the ExecType

2015-10-01 12:33:38,080 [main] INFO  org.apache.pig.Main - Apache Pig version 0.15.0 (r1682971) compiled Jun 01 2015, 11:44:35
2015-10-01 12:33:38,080 [main] INFO  org.apache.pig.Main - Logging error messages to: /home/Hadoop/pig_1443683018078.log
2015-10-01 12:33:38,242 [main] INFO  org.apache.pig.impl.util.Utils - Default bootup file /home/Hadoop/.pigbootup not found
  
2015-10-01 12:33:39,630 [main]
INFO org.apache.pig.backend.hadoop.executionengine.HExecutionEngine - Connecting to hadoop file system at: hdfs://localhost:9000
 
grunt>

ดำเนินการคำสั่งโหลด

ตอนนี้โหลดข้อมูลจากไฟล์ student_data.txt ลงใน Pig โดยดำเนินการคำสั่ง Pig Latin ต่อไปนี้ใน Grunt shell

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' 
   USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, 
   city:chararray );

ต่อไปนี้เป็นคำอธิบายของข้อความข้างต้น

ชื่อความสัมพันธ์	เราได้จัดเก็บข้อมูลไว้ในสคีมา student.
อินพุตไฟล์พา ธ	เรากำลังอ่านข้อมูลจากไฟล์ student_data.txt, ซึ่งอยู่ในไดเร็กทอรี / pig_data / ของ HDFS
ฟังก์ชั่นการจัดเก็บ	เราได้ใช้ไฟล์ PigStorage()ฟังก์ชัน โหลดและจัดเก็บข้อมูลเป็นไฟล์ข้อความที่มีโครงสร้าง ใช้ตัวคั่นโดยใช้ซึ่งแต่ละเอนทิตีของทูเปิลถูกแยกออกเป็นพารามิเตอร์ โดยค่าเริ่มต้นจะใช้ "\ t" เป็นพารามิเตอร์
สคีมา	เราได้จัดเก็บข้อมูลโดยใช้สคีมาต่อไปนี้ คอลัมน์ id ชื่อจริง นามสกุล โทรศัพท์ เมือง ประเภทข้อมูล int อาร์เรย์ถ่าน อาร์เรย์ถ่าน อาร์เรย์ถ่าน อาร์เรย์ถ่าน

Note - loadคำสั่งจะโหลดข้อมูลลงในความสัมพันธ์ที่ระบุใน Pig เพื่อตรวจสอบการดำเนินการของไฟล์Load คุณต้องใช้ไฟล์ Diagnostic Operators ซึ่งจะกล่าวถึงในบทต่อไป

ในบทที่แล้วเราได้เรียนรู้วิธีโหลดข้อมูลลงใน Apache Pig คุณสามารถจัดเก็บข้อมูลที่โหลดในระบบไฟล์โดยใช้ไฟล์storeตัวดำเนินการ บทนี้อธิบายวิธีการจัดเก็บข้อมูลใน Apache Pig โดยใช้ไฟล์Store ตัวดำเนินการ

ไวยากรณ์

ด้านล่างนี้คือไวยากรณ์ของคำสั่ง Store

STORE Relation_name INTO ' required_directory_path ' [USING function];

ตัวอย่าง

สมมติว่าเรามีไฟล์ student_data.txt ใน HDFS ที่มีเนื้อหาต่อไปนี้

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

และเราได้อ่านมันเป็นความสัมพันธ์ student โดยใช้ตัวดำเนินการ LOAD ดังที่แสดงด้านล่าง

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' 
   USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, 
   city:chararray );

ตอนนี้ให้เราเก็บความสัมพันธ์ในไดเรกทอรี HDFS “/pig_Output/” ดังแสดงด้านล่าง

grunt> STORE student INTO ' hdfs://localhost:9000/pig_Output/ ' USING PigStorage (',');

เอาต์พุต

หลังจากดำเนินการ storeคุณจะได้ผลลัพธ์ดังต่อไปนี้ ไดเร็กทอรีถูกสร้างขึ้นด้วยชื่อที่ระบุและข้อมูลจะถูกเก็บไว้ในนั้น

2015-10-05 13:05:05,429 [main] INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.
MapReduceLau ncher - 100% complete
2015-10-05 13:05:05,429 [main] INFO  org.apache.pig.tools.pigstats.mapreduce.SimplePigStats - 
Script Statistics:
   
HadoopVersion    PigVersion    UserId    StartedAt             FinishedAt             Features 
2.6.0            0.15.0        Hadoop    2015-10-0 13:03:03    2015-10-05 13:05:05    UNKNOWN  
Success!  
Job Stats (time in seconds): 
JobId          Maps    Reduces    MaxMapTime    MinMapTime    AvgMapTime    MedianMapTime    
job_14459_06    1        0           n/a           n/a           n/a           n/a
MaxReduceTime    MinReduceTime    AvgReduceTime    MedianReducetime    Alias    Feature   
     0                 0                0                0             student  MAP_ONLY 
OutPut folder
hdfs://localhost:9000/pig_Output/ 
 
Input(s): Successfully read 0 records from: "hdfs://localhost:9000/pig_data/student_data.txt"  
Output(s): Successfully stored 0 records in: "hdfs://localhost:9000/pig_Output"  
Counters:
Total records written : 0
Total bytes written : 0
Spillable Memory Manager spill count : 0 
Total bags proactively spilled: 0
Total records proactively spilled: 0
  
Job DAG: job_1443519499159_0006
  
2015-10-05 13:06:06,192 [main] INFO  org.apache.pig.backend.hadoop.executionengine
.mapReduceLayer.MapReduceLau ncher - Success!

การยืนยัน

คุณสามารถตรวจสอบข้อมูลที่จัดเก็บได้ตามที่แสดงด้านล่าง

ขั้นตอนที่ 1

ก่อนอื่นแสดงรายการไฟล์ในไดเร็กทอรีชื่อ pig_output ใช้ ls คำสั่งดังที่แสดงด้านล่าง

hdfs dfs -ls 'hdfs://localhost:9000/pig_Output/'
Found 2 items
rw-r--r-   1 Hadoop supergroup          0 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/_SUCCESS
rw-r--r-   1 Hadoop supergroup        224 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/part-m-00000

คุณสามารถสังเกตได้ว่าไฟล์สองไฟล์ถูกสร้างขึ้นหลังจากเรียกใช้ไฟล์ store คำให้การ.

ขั้นตอนที่ 2

การใช้ cat คำสั่งแสดงรายการเนื้อหาของไฟล์ชื่อ part-m-00000 ดังแสดงด้านล่าง

$ hdfs dfs -cat 'hdfs://localhost:9000/pig_Output/part-m-00000' 
1,Rajiv,Reddy,9848022337,Hyderabad
2,siddarth,Battacharya,9848022338,Kolkata
3,Rajesh,Khanna,9848022339,Delhi
4,Preethi,Agarwal,9848022330,Pune
5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
6,Archana,Mishra,9848022335,Chennai

loadคำสั่งจะโหลดข้อมูลลงในความสัมพันธ์ที่ระบุใน Apache Pig เพื่อตรวจสอบการดำเนินการของไฟล์Load คุณต้องใช้ไฟล์ Diagnostic Operators. Pig Latin มีตัวดำเนินการวินิจฉัยสี่ประเภทที่แตกต่างกัน -

• ผู้ดำเนินการถ่ายโอนข้อมูล
• อธิบายตัวดำเนินการ
• ตัวดำเนินการคำอธิบาย
• ตัวดำเนินการภาพประกอบ

ในบทนี้เราจะพูดถึงตัวดำเนินการถ่ายโอนข้อมูลของ Pig Latin

Dump Operator

Dumpตัวดำเนินการใช้เพื่อเรียกใช้คำสั่ง Pig Latin และแสดงผลลัพธ์บนหน้าจอ โดยทั่วไปจะใช้สำหรับการดีบัก Purpose

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ Dump ตัวดำเนินการ

grunt> Dump Relation_Name

ตัวอย่าง

สมมติว่าเรามีไฟล์ student_data.txt ใน HDFS ที่มีเนื้อหาต่อไปนี้

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

และเราได้อ่านมันเป็นความสัมพันธ์ student โดยใช้ตัวดำเนินการ LOAD ดังที่แสดงด้านล่าง

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' 
   USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, 
   city:chararray );

ตอนนี้ให้เราพิมพ์เนื้อหาของความสัมพันธ์โดยใช้ Dump operator ดังแสดงด้านล่าง

grunt> Dump student

เมื่อคุณดำเนินการข้างต้น Pig Latinมันจะเริ่มงาน MapReduce เพื่ออ่านข้อมูลจาก HDFS มันจะสร้างผลลัพธ์ต่อไปนี้

2015-10-01 15:05:27,642 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLauncher - 
100% complete
2015-10-01 15:05:27,652 [main]
INFO  org.apache.pig.tools.pigstats.mapreduce.SimplePigStats - Script Statistics:   
HadoopVersion  PigVersion  UserId    StartedAt             FinishedAt       Features             
2.6.0          0.15.0      Hadoop  2015-10-01 15:03:11  2015-10-01 05:27     UNKNOWN
                                                
Success!  
Job Stats (time in seconds):
  
JobId           job_14459_0004
Maps                 1  
Reduces              0  
MaxMapTime          n/a    
MinMapTime          n/a
AvgMapTime          n/a 
MedianMapTime       n/a
MaxReduceTime        0
MinReduceTime        0  
AvgReduceTime        0
MedianReducetime     0
Alias             student 
Feature           MAP_ONLY        
Outputs           hdfs://localhost:9000/tmp/temp580182027/tmp757878456,

Input(s): Successfully read 0 records from: "hdfs://localhost:9000/pig_data/
student_data.txt"
  
Output(s): Successfully stored 0 records in: "hdfs://localhost:9000/tmp/temp580182027/
tmp757878456"  

Counters: Total records written : 0 Total bytes written : 0 Spillable Memory Manager 
spill count : 0Total bags proactively spilled: 0 Total records proactively spilled: 0  

Job DAG: job_1443519499159_0004
  
2015-10-01 15:06:28,403 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLau ncher - Success!
2015-10-01 15:06:28,441 [main] INFO  org.apache.pig.data.SchemaTupleBackend - 
Key [pig.schematuple] was not set... will not generate code.
2015-10-01 15:06:28,485 [main]
INFO  org.apache.hadoop.mapreduce.lib.input.FileInputFormat - Total input paths 
to process : 1
2015-10-01 15:06:28,485 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.util.MapRedUtil - Total input paths
to process : 1

(1,Rajiv,Reddy,9848022337,Hyderabad) (2,siddarth,Battacharya,9848022338,Kolkata) (3,Rajesh,Khanna,9848022339,Delhi) (4,Preethi,Agarwal,9848022330,Pune) (5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar) (6,Archana,Mishra,9848022335,Chennai)

describe ตัวดำเนินการใช้เพื่อดูสคีมาของความสัมพันธ์

ไวยากรณ์

ไวยากรณ์ของ describe ตัวดำเนินการมีดังนี้ -

grunt> Describe Relation_name

ตัวอย่าง

สมมติว่าเรามีไฟล์ student_data.txt ใน HDFS ที่มีเนื้อหาต่อไปนี้

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

และเราได้อ่านมันเป็นความสัมพันธ์ student โดยใช้ตัวดำเนินการ LOAD ดังที่แสดงด้านล่าง

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

ตอนนี้ให้เราอธิบายความสัมพันธ์ที่ชื่อ student และตรวจสอบสคีมาตามที่แสดงด้านล่าง

grunt> describe student;

เอาต์พุต

เมื่อคุณดำเนินการข้างต้น Pig Latin มันจะสร้างผลลัพธ์ต่อไปนี้

grunt> student: { id: int,firstname: chararray,lastname: chararray,phone: chararray,city: chararray }

explain ตัวดำเนินการใช้เพื่อแสดงแผนการดำเนินการทางตรรกะทางกายภาพและ MapReduce ของความสัมพันธ์

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ explain ตัวดำเนินการ

grunt> explain Relation_name;

ตัวอย่าง

สมมติว่าเรามีไฟล์ student_data.txt ใน HDFS ที่มีเนื้อหาต่อไปนี้

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

และเราได้อ่านมันเป็นความสัมพันธ์ student โดยใช้ตัวดำเนินการ LOAD ดังที่แสดงด้านล่าง

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

ตอนนี้ให้เราอธิบายความสัมพันธ์ที่ตั้งชื่อนักเรียนโดยใช้ explain ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> explain student;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้

$ explain student;

2015-10-05 11:32:43,660 [main]
2015-10-05 11:32:43,660 [main] INFO  org.apache.pig.newplan.logical.optimizer
.LogicalPlanOptimizer -
{RULES_ENABLED=[AddForEach, ColumnMapKeyPrune, ConstantCalculator,
GroupByConstParallelSetter, LimitOptimizer, LoadTypeCastInserter, MergeFilter, 
MergeForEach, PartitionFilterOptimizer, PredicatePushdownOptimizer,
PushDownForEachFlatten, PushUpFilter, SplitFilter, StreamTypeCastInserter]}  
#-----------------------------------------------
# New Logical Plan: 
#-----------------------------------------------
student: (Name: LOStore Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)
| 
|---student: (Name: LOForEach Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)
    |   |
    |   (Name: LOGenerate[false,false,false,false,false] Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)ColumnPrune:InputUids=[34, 35, 32, 33,
31]ColumnPrune:OutputUids=[34, 35, 32, 33, 31]
    |   |   | 
    |   |   (Name: Cast Type: int Uid: 31) 
    |   |   |     |   |   |---id:(Name: Project Type: bytearray Uid: 31 Input: 0 Column: (*))
    |   |   |     
    |   |   (Name: Cast Type: chararray Uid: 32)
    |   |   | 
    |   |   |---firstname:(Name: Project Type: bytearray Uid: 32 Input: 1
Column: (*))
    |   |   |
    |   |   (Name: Cast Type: chararray Uid: 33)
    |   |   |
    |   |   |---lastname:(Name: Project Type: bytearray Uid: 33 Input: 2
	 Column: (*))
    |   |   | 
    |   |   (Name: Cast Type: chararray Uid: 34)
    |   |   |  
    |   |   |---phone:(Name: Project Type: bytearray Uid: 34 Input: 3 Column:
(*))
    |   |   | 
    |   |   (Name: Cast Type: chararray Uid: 35)
    |   |   |  
    |   |   |---city:(Name: Project Type: bytearray Uid: 35 Input: 4 Column:
(*))
    |   | 
    |   |---(Name: LOInnerLoad[0] Schema: id#31:bytearray)
    |   |  
    |   |---(Name: LOInnerLoad[1] Schema: firstname#32:bytearray)
    |   |
    |   |---(Name: LOInnerLoad[2] Schema: lastname#33:bytearray)
    |   |
    |   |---(Name: LOInnerLoad[3] Schema: phone#34:bytearray)
    |   | 
    |   |---(Name: LOInnerLoad[4] Schema: city#35:bytearray)
    |
    |---student: (Name: LOLoad Schema: 
id#31:bytearray,firstname#32:bytearray,lastname#33:bytearray,phone#34:bytearray
,city#35:bytearray)RequiredFields:null 
#-----------------------------------------------
# Physical Plan: #-----------------------------------------------
student: Store(fakefile:org.apache.pig.builtin.PigStorage) - scope-36
| 
|---student: New For Each(false,false,false,false,false)[bag] - scope-35
    |   |
    |   Cast[int] - scope-21
    |   |
    |   |---Project[bytearray][0] - scope-20
    |   |  
    |   Cast[chararray] - scope-24
    |   |
    |   |---Project[bytearray][1] - scope-23
    |   | 
    |   Cast[chararray] - scope-27
    |   |  
    |   |---Project[bytearray][2] - scope-26 
    |   |  
    |   Cast[chararray] - scope-30 
    |   |  
    |   |---Project[bytearray][3] - scope-29
    |   |
    |   Cast[chararray] - scope-33
    |   | 
    |   |---Project[bytearray][4] - scope-32
    | 
    |---student: Load(hdfs://localhost:9000/pig_data/student_data.txt:PigStorage(',')) - scope19
2015-10-05 11:32:43,682 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MRCompiler - 
File concatenation threshold: 100 optimistic? false
2015-10-05 11:32:43,684 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MultiQueryOp timizer - 
MR plan size before optimization: 1 2015-10-05 11:32:43,685 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.
MultiQueryOp timizer - MR plan size after optimization: 1 
#--------------------------------------------------
# Map Reduce Plan                                   
#--------------------------------------------------
MapReduce node scope-37
Map Plan
student: Store(fakefile:org.apache.pig.builtin.PigStorage) - scope-36
|
|---student: New For Each(false,false,false,false,false)[bag] - scope-35
    |   |
    |   Cast[int] - scope-21 
    |   |
    |   |---Project[bytearray][0] - scope-20
    |   |
    |   Cast[chararray] - scope-24
    |   |
    |   |---Project[bytearray][1] - scope-23
    |   |
    |   Cast[chararray] - scope-27
    |   | 
    |   |---Project[bytearray][2] - scope-26 
    |   | 
    |   Cast[chararray] - scope-30 
    |   |  
    |   |---Project[bytearray][3] - scope-29 
    |   | 
    |   Cast[chararray] - scope-33
    |   | 
    |   |---Project[bytearray][4] - scope-32 
    |  
    |---student:
Load(hdfs://localhost:9000/pig_data/student_data.txt:PigStorage(',')) - scope
19-------- Global sort: false
 ----------------

illustrate โอเปอเรเตอร์ช่วยให้คุณสามารถดำเนินการตามลำดับขั้นตอนของคำสั่งได้

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ illustrate ตัวดำเนินการ

grunt> illustrate Relation_name;

ตัวอย่าง

สมมติว่าเรามีไฟล์ student_data.txt ใน HDFS ที่มีเนื้อหาต่อไปนี้

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata 
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune 
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

และเราได้อ่านมันเป็นความสัมพันธ์ student โดยใช้ตัวดำเนินการ LOAD ดังที่แสดงด้านล่าง

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

ตอนนี้ให้เราแสดงความสัมพันธ์ที่ชื่อนักเรียนดังที่แสดงด้านล่าง

grunt> illustrate student;

เอาต์พุต

ในการดำเนินการคำสั่งข้างต้นคุณจะได้ผลลัพธ์ดังต่อไปนี้

grunt> illustrate student;

INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigMapOnly$M ap - Aliases
being processed per job phase (AliasName[line,offset]): M: student[1,10] C:  R:
---------------------------------------------------------------------------------------------
|student | id:int | firstname:chararray | lastname:chararray | phone:chararray | city:chararray |
--------------------------------------------------------------------------------------------- 
|        | 002    | siddarth            | Battacharya        | 9848022338      | Kolkata        |
---------------------------------------------------------------------------------------------

GROUPตัวดำเนินการใช้เพื่อจัดกลุ่มข้อมูลในความสัมพันธ์อย่างน้อยหนึ่งความสัมพันธ์ รวบรวมข้อมูลที่มีคีย์เดียวกัน

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ group ตัวดำเนินการ

grunt> Group_data = GROUP Relation_name BY age;

ตัวอย่าง

สมมติว่าเรามีไฟล์ชื่อ student_details.txt ในไดเร็กทอรี HDFS /pig_data/ ดังแสดงด้านล่าง

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai

และเราได้โหลดไฟล์นี้ลงใน Apache Pig ด้วยชื่อความสัมพันธ์ student_details ดังแสดงด้านล่าง

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

ตอนนี้ให้เราจัดกลุ่มระเบียน / tuples ตามความสัมพันธ์ตามอายุดังที่แสดงด้านล่าง

grunt> group_data = GROUP student_details by age;

การยืนยัน

ตรวจสอบความสัมพันธ์ group_data ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump group_data;

เอาต์พุต

จากนั้นคุณจะได้รับผลลัพธ์ที่แสดงเนื้อหาของความสัมพันธ์ที่ตั้งชื่อ group_dataดังแสดงด้านล่าง ที่นี่คุณสามารถสังเกตได้ว่าสคีมาที่เป็นผลลัพธ์มีสองคอลัมน์ -

• หนึ่งคือ ageโดยเราได้จัดกลุ่มความสัมพันธ์

• อีกอันคือก bagซึ่งประกอบด้วยกลุ่มทูเปิลบันทึกของนักเรียนตามอายุตามลำดับ

(21,{(4,Preethi,Agarwal,21,9848022330,Pune),(1,Rajiv,Reddy,21,9848022337,Hydera bad)})
(22,{(3,Rajesh,Khanna,22,9848022339,Delhi),(2,siddarth,Battacharya,22,984802233 8,Kolkata)})
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)})
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)})

คุณสามารถดูสคีมาของตารางหลังจากจัดกลุ่มข้อมูลโดยใช้ไฟล์ describe คำสั่งดังที่แสดงด้านล่าง

grunt> Describe group_data;
  
group_data: {group: int,student_details: {(id: int,firstname: chararray,
               lastname: chararray,age: int,phone: chararray,city: chararray)}}

ในทำนองเดียวกันคุณสามารถรับภาพประกอบตัวอย่างของสคีมาโดยใช้ไฟล์ illustrate คำสั่งดังที่แสดงด้านล่าง

$ Illustrate group_data;

มันจะสร้างผลลัพธ์ต่อไปนี้ -

------------------------------------------------------------------------------------------------- 
|group_data|  group:int | student_details:bag{:tuple(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray)}|
------------------------------------------------------------------------------------------------- 
|          |     21     | { 4, Preethi, Agarwal, 21, 9848022330, Pune), (1, Rajiv, Reddy, 21, 9848022337, Hyderabad)}| 
|          |     2      | {(2,siddarth,Battacharya,22,9848022338,Kolkata),(003,Rajesh,Khanna,22,9848022339,Delhi)}| 
-------------------------------------------------------------------------------------------------

การจัดกลุ่มตามหลายคอลัมน์

ให้เราจัดกลุ่มความสัมพันธ์ตามอายุและเมืองดังที่แสดงด้านล่าง

grunt> group_multiple = GROUP student_details by (age, city);

คุณสามารถตรวจสอบเนื้อหาของความสัมพันธ์ที่ตั้งชื่อ group_multiple โดยใช้ตัวดำเนินการถ่ายโอนข้อมูลดังที่แสดงด้านล่าง

grunt> Dump group_multiple; 
  
((21,Pune),{(4,Preethi,Agarwal,21,9848022330,Pune)})
((21,Hyderabad),{(1,Rajiv,Reddy,21,9848022337,Hyderabad)})
((22,Delhi),{(3,Rajesh,Khanna,22,9848022339,Delhi)})
((22,Kolkata),{(2,siddarth,Battacharya,22,9848022338,Kolkata)})
((23,Chennai),{(6,Archana,Mishra,23,9848022335,Chennai)})
((23,Bhuwaneshwar),{(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)})
((24,Chennai),{(8,Bharathi,Nambiayar,24,9848022333,Chennai)})
(24,trivendram),{(7,Komal,Nayak,24,9848022334,trivendram)})

กลุ่มทั้งหมด

คุณสามารถจัดกลุ่มความสัมพันธ์ตามคอลัมน์ทั้งหมดดังที่แสดงด้านล่าง

grunt> group_all = GROUP student_details All;

ตอนนี้ตรวจสอบเนื้อหาของความสัมพันธ์ group_all ดังแสดงด้านล่าง

grunt> Dump group_all;  
  
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334 ,trivendram), 
(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336,Bhuw aneshwar), 
(4,Preethi,Agarwal,21,9848022330,Pune),(3,Rajesh,Khanna,22,9848022339,Delhi), 
(2,siddarth,Battacharya,22,9848022338,Kolkata),(1,Rajiv,Reddy,21,9848022337,Hyd erabad)})

COGROUPตัวดำเนินการทำงานมากหรือน้อยในลักษณะเดียวกับตัวดำเนินการGROUP ข้อแตกต่างเพียงอย่างเดียวระหว่างตัวดำเนินการทั้งสองคือgroup โดยปกติตัวดำเนินการจะใช้กับความสัมพันธ์เดียวในขณะที่ cogroup ตัวดำเนินการใช้ในคำสั่งที่เกี่ยวข้องกับความสัมพันธ์สองอย่างขึ้นไป

การจัดกลุ่มสองความสัมพันธ์โดยใช้ Cogroup

สมมติว่าเรามีสองไฟล์คือ student_details.txt และ employee_details.txt ในไดเร็กทอรี HDFS /pig_data/ ดังแสดงด้านล่าง

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai

employee_details.txt

001,Robin,22,newyork 
002,BOB,23,Kolkata 
003,Maya,23,Tokyo 
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai

และเราได้โหลดไฟล์เหล่านี้ลงใน Pig พร้อมชื่อความสัมพันธ์ student_details และ employee_details ตามลำดับดังที่แสดงด้านล่าง

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray); 
  
grunt> employee_details = LOAD 'hdfs://localhost:9000/pig_data/employee_details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);

ตอนนี้ให้เราจัดกลุ่มเร็กคอร์ด / ทูเปิลของความสัมพันธ์ student_details และ employee_details ด้วยอายุคีย์ดังที่แสดงด้านล่าง

grunt> cogroup_data = COGROUP student_details by age, employee_details by age;

การยืนยัน

ตรวจสอบความสัมพันธ์ cogroup_data ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump cogroup_data;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ที่ชื่อ cogroup_data ดังแสดงด้านล่าง

(21,{(4,Preethi,Agarwal,21,9848022330,Pune), (1,Rajiv,Reddy,21,9848022337,Hyderabad)}, 
   {    })  
(22,{ (3,Rajesh,Khanna,22,9848022339,Delhi), (2,siddarth,Battacharya,22,9848022338,Kolkata) },  
   { (6,Maggy,22,Chennai),(1,Robin,22,newyork) })  
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)}, 
   {(5,David,23,Bhuwaneshwar),(3,Maya,23,Tokyo),(2,BOB,23,Kolkata)}) 
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)}, 
   { })  
(25,{   }, 
   {(4,Sara,25,London)})

cogroup ตัวดำเนินการจัดกลุ่มสิ่งที่เพิ่มขึ้นจากแต่ละความสัมพันธ์ตามอายุโดยที่แต่ละกลุ่มแสดงถึงค่าอายุเฉพาะ

ตัวอย่างเช่นหากเราพิจารณาทูเปิลแรกของผลลัพธ์มันจะถูกจัดกลุ่มตามอายุ 21 และมันมีสองถุง -

• ถุงแรกถือสิ่งที่ได้ทั้งหมดจากความสัมพันธ์แรก (student_details ในกรณีนี้) มีอายุ 21 ปีและ

• ถุงที่สองมีสิ่งที่เพิ่มขึ้นทั้งหมดจากความสัมพันธ์ที่สอง (employee_details ในกรณีนี้) มีอายุ 21 ปี

ในกรณีที่ความสัมพันธ์ไม่มีสิ่งที่มีค่าอายุ 21 จะส่งคืนถุงเปล่า

JOINตัวดำเนินการใช้เพื่อรวมเร็กคอร์ดจากสองความสัมพันธ์ขึ้นไป ในขณะดำเนินการเข้าร่วมเราประกาศทูเพิลหนึ่ง (หรือกลุ่ม) จากแต่ละรีเลชันเป็นคีย์ เมื่อคีย์เหล่านี้ตรงกันทูเปิลสองตัวจะตรงกันมิฉะนั้นเร็กคอร์ดจะถูกทิ้ง การเข้าร่วมสามารถเป็นประเภทต่อไปนี้ -

• Self-join
• Inner-join
• การเข้าร่วมภายนอก - การเข้าร่วมทางซ้ายการเข้าร่วมทางขวาและการเข้าร่วมแบบเต็ม

บทนี้อธิบายด้วยตัวอย่างวิธีการใช้ตัวดำเนินการเข้าร่วมใน Pig Latin สมมติว่าเรามีสองไฟล์คือcustomers.txt และ orders.txt ใน /pig_data/ ไดเรกทอรีของ HDFS ดังแสดงด้านล่าง

customers.txt

1,Ramesh,32,Ahmedabad,2000.00
2,Khilan,25,Delhi,1500.00
3,kaushik,23,Kota,2000.00
4,Chaitali,25,Mumbai,6500.00 
5,Hardik,27,Bhopal,8500.00
6,Komal,22,MP,4500.00
7,Muffy,24,Indore,10000.00

orders.txt

102,2009-10-08 00:00:00,3,3000
100,2009-10-08 00:00:00,3,1500
101,2009-11-20 00:00:00,2,1560
103,2008-05-20 00:00:00,4,2060

และเราได้โหลดไฟล์ทั้งสองนี้ลงใน Pig ด้วยความสัมพันธ์ customers และ orders ดังแสดงด้านล่าง

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);
  
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')
   as (oid:int, date:chararray, customer_id:int, amount:int);

ตอนนี้ให้เราดำเนินการเข้าร่วมต่างๆในความสัมพันธ์ทั้งสองนี้

เข้าร่วมด้วยตนเอง

Self-join ใช้เพื่อเข้าร่วมตารางกับตัวเองราวกับว่าตารางเป็นสองความสัมพันธ์โดยเปลี่ยนชื่ออย่างน้อยหนึ่งความสัมพันธ์ชั่วคราว

โดยทั่วไปใน Apache Pig ในการเข้าร่วมด้วยตนเองเราจะโหลดข้อมูลเดียวกันหลายครั้งภายใต้นามแฝง (ชื่อ) ที่แตกต่างกัน ดังนั้นให้เราโหลดเนื้อหาของไฟล์customers.txt เป็นสองตารางดังที่แสดงด้านล่าง

grunt> customers1 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);
  
grunt> customers2 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);

ไวยากรณ์

ด้านล่างเป็นไวยากรณ์ของการแสดง self-join การดำเนินการโดยใช้ JOIN ตัวดำเนินการ

grunt> Relation3_name = JOIN Relation1_name BY key, Relation2_name BY key ;

ตัวอย่าง

ให้เราดำเนินการ self-join การดำเนินการเกี่ยวกับความสัมพันธ์ customersโดยการเข้าร่วมความสัมพันธ์ทั้งสอง customers1 และ customers2 ดังแสดงด้านล่าง

grunt> customers3 = JOIN customers1 BY id, customers2 BY id;

การยืนยัน

ตรวจสอบความสัมพันธ์ customers3 ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump customers3;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ customers.

(1,Ramesh,32,Ahmedabad,2000,1,Ramesh,32,Ahmedabad,2000)
(2,Khilan,25,Delhi,1500,2,Khilan,25,Delhi,1500)
(3,kaushik,23,Kota,2000,3,kaushik,23,Kota,2000)
(4,Chaitali,25,Mumbai,6500,4,Chaitali,25,Mumbai,6500)
(5,Hardik,27,Bhopal,8500,5,Hardik,27,Bhopal,8500)
(6,Komal,22,MP,4500,6,Komal,22,MP,4500)
(7,Muffy,24,Indore,10000,7,Muffy,24,Indore,10000)

การเข้าร่วมภายใน

Inner Joinถูกใช้ค่อนข้างบ่อย เรียกอีกอย่างว่าequijoin. การรวมภายในจะส่งคืนแถวเมื่อมีการจับคู่ในทั้งสองตาราง

สร้างความสัมพันธ์ใหม่โดยการรวมค่าคอลัมน์ของสองความสัมพันธ์ (พูดว่า A และ B) ตามคำกริยาเข้าร่วม แบบสอบถามเปรียบเทียบแต่ละแถวของ A กับแต่ละแถวของ B เพื่อค้นหาคู่ของแถวทั้งหมดที่ตรงกับคำกริยาเข้าร่วม เมื่อเข้าร่วมเพรดิเคตเป็นที่พอใจแล้วค่าของคอลัมน์สำหรับแถว A และ B ที่ตรงกันแต่ละคู่จะรวมกันเป็นแถวผลลัพธ์

ไวยากรณ์

นี่คือไวยากรณ์ของการแสดง inner join การดำเนินการโดยใช้ JOIN ตัวดำเนินการ

grunt> result = JOIN relation1 BY columnname, relation2 BY columnname;

ตัวอย่าง

ให้เราดำเนินการ inner join การดำเนินการกับสองความสัมพันธ์ customers และ orders ดังแสดงด้านล่าง

grunt> coustomer_orders = JOIN customers BY id, orders BY customer_id;

การยืนยัน

ตรวจสอบความสัมพันธ์ coustomer_orders ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump coustomer_orders;

เอาต์พุต

คุณจะได้รับผลลัพธ์ต่อไปนี้ซึ่งจะเป็นเนื้อหาของความสัมพันธ์ที่มีชื่อว่า coustomer_orders.

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

Note -

การเข้าร่วมภายนอก : ไม่เหมือนกับการเข้าร่วมภายในouter joinส่งคืนแถวทั้งหมดจากความสัมพันธ์อย่างน้อยหนึ่งความสัมพันธ์ การรวมภายนอกดำเนินการได้สามวิธี -

• การรวมภายนอกด้านซ้าย
• การรวมภายนอกด้านขวา
• การเข้าร่วมภายนอกเต็มรูปแบบ

เข้าร่วมด้านนอกซ้าย

left outer Join การดำเนินการส่งคืนแถวทั้งหมดจากตารางด้านซ้ายแม้ว่าจะไม่มีการจับคู่ในความสัมพันธ์ด้านขวาก็ตาม

ไวยากรณ์

ด้านล่างเป็นไวยากรณ์ของการแสดง left outer join การดำเนินการโดยใช้ JOIN ตัวดำเนินการ

grunt> Relation3_name = JOIN Relation1_name BY id LEFT OUTER, Relation2_name BY customer_id;

ตัวอย่าง

ให้เราดำเนินการเข้าร่วมภายนอกด้านซ้ายกับลูกค้าสัมพันธ์สองรายและคำสั่งซื้อดังที่แสดงด้านล่าง

grunt> outer_left = JOIN customers BY id LEFT OUTER, orders BY customer_id;

การยืนยัน

ตรวจสอบความสัมพันธ์ outer_left ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump outer_left;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ outer_left.

(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,,,,)
(6,Komal,22,MP,4500,,,,)
(7,Muffy,24,Indore,10000,,,,)

เข้าร่วมภายนอกขวา

right outer join การดำเนินการส่งคืนแถวทั้งหมดจากตารางด้านขวาแม้ว่าจะไม่มีรายการที่ตรงกันในตารางด้านซ้าย

ไวยากรณ์

ด้านล่างเป็นไวยากรณ์ของการแสดง right outer join การดำเนินการโดยใช้ JOIN ตัวดำเนินการ

grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;

ตัวอย่าง

ให้เราดำเนินการ right outer join การดำเนินการกับสองความสัมพันธ์ customers และ orders ดังแสดงด้านล่าง

grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;

การยืนยัน

ตรวจสอบความสัมพันธ์ outer_right ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump outer_right

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ outer_right.

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

เข้าร่วมภายนอกเต็มรูปแบบ

full outer join การดำเนินการส่งคืนแถวเมื่อมีการจับคู่ในความสัมพันธ์อย่างใดอย่างหนึ่ง

ไวยากรณ์

ด้านล่างเป็นไวยากรณ์ของการแสดง full outer join ใช้ JOIN ตัวดำเนินการ

grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;

ตัวอย่าง

ให้เราดำเนินการ full outer join การดำเนินการกับสองความสัมพันธ์ customers และ orders ดังแสดงด้านล่าง

grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;

การยืนยัน

ตรวจสอบความสัมพันธ์ outer_full ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grun> Dump outer_full;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ outer_full.

(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,,,,)
(6,Komal,22,MP,4500,,,,)
(7,Muffy,24,Indore,10000,,,,)

การใช้ปุ่มหลายปุ่ม

เราสามารถทำการ JOIN โดยใช้ปุ่มหลายปุ่ม

ไวยากรณ์

นี่คือวิธีที่คุณสามารถดำเนินการ JOIN บนสองตารางโดยใช้หลายปุ่ม

grunt> Relation3_name = JOIN Relation2_name BY (key1, key2), Relation3_name BY (key1, key2);

สมมติว่าเรามีสองไฟล์คือ employee.txt และ employee_contact.txt ใน /pig_data/ ไดเรกทอรีของ HDFS ดังแสดงด้านล่าง

employee.txt

001,Rajiv,Reddy,21,programmer,003
002,siddarth,Battacharya,22,programmer,003
003,Rajesh,Khanna,22,programmer,003
004,Preethi,Agarwal,21,programmer,003
005,Trupthi,Mohanthy,23,programmer,003
006,Archana,Mishra,23,programmer,003
007,Komal,Nayak,24,teamlead,002
008,Bharathi,Nambiayar,24,manager,001

employee_contact.txt

001,9848022337,[email protected],Hyderabad,003
002,9848022338,[email protected],Kolkata,003
003,9848022339,[email protected],Delhi,003
004,9848022330,[email protected],Pune,003
005,9848022336,[email protected],Bhuwaneshwar,003
006,9848022335,[email protected],Chennai,003
007,9848022334,[email protected],trivendram,002
008,9848022333,[email protected],Chennai,001

และเราได้โหลดสองไฟล์นี้ลงใน Pig ด้วยความสัมพันธ์ employee และ employee_contact ดังแสดงด้านล่าง

grunt> employee = LOAD 'hdfs://localhost:9000/pig_data/employee.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, designation:chararray, jobid:int);
  
grunt> employee_contact = LOAD 'hdfs://localhost:9000/pig_data/employee_contact.txt' USING PigStorage(',') 
   as (id:int, phone:chararray, email:chararray, city:chararray, jobid:int);

ตอนนี้ให้เราเข้าร่วมเนื้อหาของความสัมพันธ์ทั้งสองนี้โดยใช้ไฟล์ JOIN ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> emp = JOIN employee BY (id,jobid), employee_contact BY (id,jobid);

การยืนยัน

ตรวจสอบความสัมพันธ์ emp ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump emp;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ที่ชื่อ emp ดังแสดงด้านล่าง

(1,Rajiv,Reddy,21,programmer,113,1,9848022337,[email protected],Hyderabad,113)
(2,siddarth,Battacharya,22,programmer,113,2,9848022338,[email protected],Kolka ta,113)  
(3,Rajesh,Khanna,22,programmer,113,3,9848022339,[email protected],Delhi,113)  
(4,Preethi,Agarwal,21,programmer,113,4,9848022330,[email protected],Pune,113)  
(5,Trupthi,Mohanthy,23,programmer,113,5,9848022336,[email protected],Bhuwaneshw ar,113)  
(6,Archana,Mishra,23,programmer,113,6,9848022335,[email protected],Chennai,113)  
(7,Komal,Nayak,24,teamlead,112,7,9848022334,[email protected],trivendram,112)  
(8,Bharathi,Nambiayar,24,manager,111,8,9848022333,[email protected],Chennai,111)

CROSSตัวดำเนินการคำนวณผลิตภัณฑ์ข้ามผลิตภัณฑ์ของความสัมพันธ์ตั้งแต่สองตัวขึ้นไป บทนี้อธิบายพร้อมตัวอย่างวิธีใช้ตัวดำเนินการข้ามใน Pig Latin

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ CROSS ตัวดำเนินการ

grunt> Relation3_name = CROSS Relation1_name, Relation2_name;

ตัวอย่าง

สมมติว่าเรามีสองไฟล์คือ customers.txt และ orders.txt ใน /pig_data/ ไดเรกทอรีของ HDFS ดังแสดงด้านล่าง

customers.txt

1,Ramesh,32,Ahmedabad,2000.00
2,Khilan,25,Delhi,1500.00
3,kaushik,23,Kota,2000.00
4,Chaitali,25,Mumbai,6500.00
5,Hardik,27,Bhopal,8500.00
6,Komal,22,MP,4500.00
7,Muffy,24,Indore,10000.00

orders.txt

102,2009-10-08 00:00:00,3,3000
100,2009-10-08 00:00:00,3,1500
101,2009-11-20 00:00:00,2,1560
103,2008-05-20 00:00:00,4,2060

และเราได้โหลดไฟล์ทั้งสองนี้ลงใน Pig ด้วยความสัมพันธ์ customers และ orders ดังแสดงด้านล่าง

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);
  
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')
   as (oid:int, date:chararray, customer_id:int, amount:int);

ตอนนี้ให้เรารับผลคูณระหว่างความสัมพันธ์ทั้งสองนี้โดยใช้ไฟล์ cross ตัวดำเนินการของความสัมพันธ์ทั้งสองนี้ดังแสดงด้านล่าง

grunt> cross_data = CROSS customers, orders;

การยืนยัน

ตรวจสอบความสัมพันธ์ cross_data ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump cross_data;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ cross_data.

(7,Muffy,24,Indore,10000,103,2008-05-20 00:00:00,4,2060) 
(7,Muffy,24,Indore,10000,101,2009-11-20 00:00:00,2,1560) 
(7,Muffy,24,Indore,10000,100,2009-10-08 00:00:00,3,1500) 
(7,Muffy,24,Indore,10000,102,2009-10-08 00:00:00,3,3000) 
(6,Komal,22,MP,4500,103,2008-05-20 00:00:00,4,2060) 
(6,Komal,22,MP,4500,101,2009-11-20 00:00:00,2,1560) 
(6,Komal,22,MP,4500,100,2009-10-08 00:00:00,3,1500) 
(6,Komal,22,MP,4500,102,2009-10-08 00:00:00,3,3000) 
(5,Hardik,27,Bhopal,8500,103,2008-05-20 00:00:00,4,2060) 
(5,Hardik,27,Bhopal,8500,101,2009-11-20 00:00:00,2,1560) 
(5,Hardik,27,Bhopal,8500,100,2009-10-08 00:00:00,3,1500) 
(5,Hardik,27,Bhopal,8500,102,2009-10-08 00:00:00,3,3000) 
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060) 
(4,Chaitali,25,Mumbai,6500,101,2009-20 00:00:00,4,2060) 
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) 
(2,Khilan,25,Delhi,1500,100,2009-10-08 00:00:00,3,1500) 
(2,Khilan,25,Delhi,1500,102,2009-10-08 00:00:00,3,3000) 
(1,Ramesh,32,Ahmedabad,2000,103,2008-05-20 00:00:00,4,2060) 
(1,Ramesh,32,Ahmedabad,2000,101,2009-11-20 00:00:00,2,1560) 
(1,Ramesh,32,Ahmedabad,2000,100,2009-10-08 00:00:00,3,1500) 
(1,Ramesh,32,Ahmedabad,2000,102,2009-10-08 00:00:00,3,3000)-11-20 00:00:00,2,1560) 
(4,Chaitali,25,Mumbai,6500,100,2009-10-08 00:00:00,3,1500) 
(4,Chaitali,25,Mumbai,6500,102,2009-10-08 00:00:00,3,3000) 
(3,kaushik,23,Kota,2000,103,2008-05-20 00:00:00,4,2060) 
(3,kaushik,23,Kota,2000,101,2009-11-20 00:00:00,2,1560) 
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500) 
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000) 
(2,Khilan,25,Delhi,1500,103,2008-05-20 00:00:00,4,2060) 
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) 
(2,Khilan,25,Delhi,1500,100,2009-10-08 00:00:00,3,1500)
(2,Khilan,25,Delhi,1500,102,2009-10-08 00:00:00,3,3000) 
(1,Ramesh,32,Ahmedabad,2000,103,2008-05-20 00:00:00,4,2060) 
(1,Ramesh,32,Ahmedabad,2000,101,2009-11-20 00:00:00,2,1560) 
(1,Ramesh,32,Ahmedabad,2000,100,2009-10-08 00:00:00,3,1500) 
(1,Ramesh,32,Ahmedabad,2000,102,2009-10-08 00:00:00,3,3000)

UNIONตัวดำเนินการของ Pig Latin ใช้เพื่อผสานเนื้อหาของความสัมพันธ์สองแบบ ในการดำเนินการ UNION กับสองความสัมพันธ์คอลัมน์และโดเมนของพวกเขาจะต้องเหมือนกัน

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ UNION ตัวดำเนินการ

grunt> Relation_name3 = UNION Relation_name1, Relation_name2;

ตัวอย่าง

สมมติว่าเรามีสองไฟล์คือ student_data1.txt และ student_data2.txt ใน /pig_data/ ไดเรกทอรีของ HDFS ดังแสดงด้านล่าง

Student_data1.txt

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

Student_data2.txt

7,Komal,Nayak,9848022334,trivendram.
8,Bharathi,Nambiayar,9848022333,Chennai.

และเราได้โหลดไฟล์ทั้งสองนี้ลงใน Pig ด้วยความสัมพันธ์ student1 และ student2 ดังแสดงด้านล่าง

grunt> student1 = LOAD 'hdfs://localhost:9000/pig_data/student_data1.txt' USING PigStorage(',') 
   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray); 
 
grunt> student2 = LOAD 'hdfs://localhost:9000/pig_data/student_data2.txt' USING PigStorage(',') 
   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);

ตอนนี้ให้เรารวมเนื้อหาของความสัมพันธ์ทั้งสองนี้โดยใช้ไฟล์ UNION ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> student = UNION student1, student2;

การยืนยัน

ตรวจสอบความสัมพันธ์ student ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump student;

เอาต์พุต

มันจะแสดงผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ student.

(1,Rajiv,Reddy,9848022337,Hyderabad) (2,siddarth,Battacharya,9848022338,Kolkata)
(3,Rajesh,Khanna,9848022339,Delhi)
(4,Preethi,Agarwal,9848022330,Pune) 
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai) 
(7,Komal,Nayak,9848022334,trivendram) 
(8,Bharathi,Nambiayar,9848022333,Chennai)

SPLIT ตัวดำเนินการใช้เพื่อแบ่งความสัมพันธ์ออกเป็นสองความสัมพันธ์หรือมากกว่า

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ SPLIT ตัวดำเนินการ

grunt> SPLIT Relation1_name INTO Relation2_name IF (condition1), Relation2_name (condition2),

ตัวอย่าง

สมมติว่าเรามีไฟล์ชื่อ student_details.txt ในไดเร็กทอรี HDFS /pig_data/ ดังแสดงด้านล่าง

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

และเราได้โหลดไฟล์นี้ลงใน Pig ด้วยชื่อความสัมพันธ์ student_details ดังแสดงด้านล่าง

student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

ตอนนี้ให้เราแบ่งความสัมพันธ์ออกเป็นสองส่วนโดยรายการหนึ่งระบุพนักงานที่อายุน้อยกว่า 23 ปีและอีกรายระบุพนักงานที่มีอายุระหว่าง 22 ถึง 25 ปี

SPLIT student_details into student_details1 if age<23, student_details2 if (22<age and age>25);

การยืนยัน

ตรวจสอบความสัมพันธ์ student_details1 และ student_details2 ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump student_details1;  

grunt> Dump student_details2;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ student_details1 และ student_details2 ตามลำดับ

grunt> Dump student_details1; 
(1,Rajiv,Reddy,21,9848022337,Hyderabad) 
(2,siddarth,Battacharya,22,9848022338,Kolkata)
(3,Rajesh,Khanna,22,9848022339,Delhi) 
(4,Preethi,Agarwal,21,9848022330,Pune)
  
grunt> Dump student_details2; 
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar) 
(6,Archana,Mishra,23,9848022335,Chennai) 
(7,Komal,Nayak,24,9848022334,trivendram) 
(8,Bharathi,Nambiayar,24,9848022333,Chennai)

FILTER ตัวดำเนินการใช้เพื่อเลือกสิ่งที่ต้องการจากความสัมพันธ์ตามเงื่อนไข

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ FILTER ตัวดำเนินการ

grunt> Relation2_name = FILTER Relation1_name BY (condition);

ตัวอย่าง

สมมติว่าเรามีไฟล์ชื่อ student_details.txt ในไดเร็กทอรี HDFS /pig_data/ ดังแสดงด้านล่าง

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

และเราได้โหลดไฟล์นี้ลงใน Pig ด้วยชื่อความสัมพันธ์ student_details ดังแสดงด้านล่าง

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

ให้เราใช้ตัวดำเนินการกรองเพื่อดูรายละเอียดของนักเรียนที่อยู่ในเมืองเจนไน

filter_data = FILTER student_details BY city == 'Chennai';

การยืนยัน

ตรวจสอบความสัมพันธ์ filter_data ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump filter_data;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ filter_data ดังต่อไปนี้.

(6,Archana,Mishra,23,9848022335,Chennai)
(8,Bharathi,Nambiayar,24,9848022333,Chennai)

DISTINCT ตัวดำเนินการใช้เพื่อลบสิ่งที่ซ้ำซ้อน (ซ้ำกัน) ออกจากความสัมพันธ์

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ DISTINCT ตัวดำเนินการ

grunt> Relation_name2 = DISTINCT Relatin_name1;

ตัวอย่าง

สมมติว่าเรามีไฟล์ชื่อ student_details.txt ในไดเร็กทอรี HDFS /pig_data/ ดังแสดงด้านล่าง

student_details.txt

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata 
002,siddarth,Battacharya,9848022338,Kolkata 
003,Rajesh,Khanna,9848022339,Delhi 
003,Rajesh,Khanna,9848022339,Delhi 
004,Preethi,Agarwal,9848022330,Pune 
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai 
006,Archana,Mishra,9848022335,Chennai

และเราได้โหลดไฟล์นี้ลงใน Pig ด้วยชื่อความสัมพันธ์ student_details ดังแสดงด้านล่าง

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',') 
   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);

ตอนนี้ให้เราลบสิ่งที่ซ้ำซ้อน (ซ้ำกัน) ออกจากความสัมพันธ์ที่มีชื่อว่า student_details ใช้ DISTINCT ตัวดำเนินการและจัดเก็บเป็นความสัมพันธ์อื่นที่ชื่อ distinct_data ดังแสดงด้านล่าง

grunt> distinct_data = DISTINCT student_details;

การยืนยัน

ตรวจสอบความสัมพันธ์ distinct_data ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump distinct_data;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ distinct_data ดังต่อไปนี้.

(1,Rajiv,Reddy,9848022337,Hyderabad)
(2,siddarth,Battacharya,9848022338,Kolkata) 
(3,Rajesh,Khanna,9848022339,Delhi) 
(4,Preethi,Agarwal,9848022330,Pune) 
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai)

FOREACH ตัวดำเนินการใช้เพื่อสร้างการแปลงข้อมูลที่ระบุตามข้อมูลคอลัมน์

ไวยากรณ์

ด้านล่างนี้คือไวยากรณ์ของ FOREACH ตัวดำเนินการ

grunt> Relation_name2 = FOREACH Relatin_name1 GENERATE (required data);

ตัวอย่าง

สมมติว่าเรามีไฟล์ชื่อ student_details.txt ในไดเร็กทอรี HDFS /pig_data/ ดังแสดงด้านล่าง

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

และเราได้โหลดไฟล์นี้ลงใน Pig ด้วยชื่อความสัมพันธ์ student_details ดังแสดงด้านล่าง

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

ตอนนี้ให้เรารับรหัสอายุและค่าเมืองของนักเรียนแต่ละคนจากความสัมพันธ์ student_details และเก็บไว้ในความสัมพันธ์อื่นที่ชื่อ foreach_data ใช้ foreach ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> foreach_data = FOREACH student_details GENERATE id,age,city;

การยืนยัน

ตรวจสอบความสัมพันธ์ foreach_data ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump foreach_data;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ foreach_data.

(1,21,Hyderabad)
(2,22,Kolkata)
(3,22,Delhi)
(4,21,Pune) 
(5,23,Bhuwaneshwar)
(6,23,Chennai) 
(7,24,trivendram)
(8,24,Chennai)

ORDER BY ตัวดำเนินการใช้เพื่อแสดงเนื้อหาของความสัมพันธ์ตามลำดับที่เรียงตามฟิลด์อย่างน้อยหนึ่งฟิลด์

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ ORDER BY ตัวดำเนินการ

grunt> Relation_name2 = ORDER Relatin_name1 BY (ASC|DESC);

ตัวอย่าง

สมมติว่าเรามีไฟล์ชื่อ student_details.txt ในไดเร็กทอรี HDFS /pig_data/ ดังแสดงด้านล่าง

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

และเราได้โหลดไฟล์นี้ลงใน Pig ด้วยชื่อความสัมพันธ์ student_details ดังแสดงด้านล่าง

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

ตอนนี้ให้เราเรียงลำดับความสัมพันธ์จากมากไปหาน้อยตามอายุของนักเรียนและจัดเก็บไว้ในความสัมพันธ์อื่นที่มีชื่อว่า order_by_data ใช้ ORDER BY ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> order_by_data = ORDER student_details BY age DESC;

การยืนยัน

ตรวจสอบความสัมพันธ์ order_by_data ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump order_by_data;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ order_by_data.

(8,Bharathi,Nambiayar,24,9848022333,Chennai)
(7,Komal,Nayak,24,9848022334,trivendram)
(6,Archana,Mishra,23,9848022335,Chennai) 
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)
(3,Rajesh,Khanna,22,9848022339,Delhi) 
(2,siddarth,Battacharya,22,9848022338,Kolkata)
(4,Preethi,Agarwal,21,9848022330,Pune) 
(1,Rajiv,Reddy,21,9848022337,Hyderabad)

LIMIT ตัวดำเนินการใช้เพื่อรับจำนวนสิ่งที่ จำกัด จากความสัมพันธ์

ไวยากรณ์

ด้านล่างนี้เป็นไวยากรณ์ของไฟล์ LIMIT ตัวดำเนินการ

grunt> Result = LIMIT Relation_name required number of tuples;

ตัวอย่าง

สมมติว่าเรามีไฟล์ชื่อ student_details.txt ในไดเร็กทอรี HDFS /pig_data/ ดังแสดงด้านล่าง

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

และเราได้โหลดไฟล์นี้ลงใน Pig ด้วยชื่อความสัมพันธ์ student_details ดังแสดงด้านล่าง

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

ตอนนี้เรามาเรียงลำดับความสัมพันธ์จากมากไปหาน้อยตามอายุของนักเรียนและจัดเก็บไว้ในความสัมพันธ์อื่นที่มีชื่อว่า limit_data ใช้ ORDER BY ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> limit_data = LIMIT student_details 4;

การยืนยัน

ตรวจสอบความสัมพันธ์ limit_data ใช้ DUMP ตัวดำเนินการดังที่แสดงด้านล่าง

grunt> Dump limit_data;

เอาต์พุต

มันจะสร้างผลลัพธ์ต่อไปนี้โดยแสดงเนื้อหาของความสัมพันธ์ limit_data ดังต่อไปนี้.

(1,Rajiv,Reddy,21,9848022337,Hyderabad) 
(2,siddarth,Battacharya,22,9848022338,Kolkata) 
(3,Rajesh,Khanna,22,9848022339,Delhi) 
(4,Preethi,Agarwal,21,9848022330,Pune)

Apache Pig มีฟังก์ชั่นในตัวที่หลากหลาย ได้แก่ eval, load, store, math, string, bag และ tuple ฟังก์ชั่น.

ฟังก์ชั่นการประเมิน

ด้านล่างคือรายการของ eval ฟังก์ชั่นที่จัดทำโดย Apache Pig

SN	ฟังก์ชั่นและคำอธิบาย
1	AVG () เพื่อคำนวณค่าเฉลี่ยของค่าตัวเลขภายในกระเป๋า
2	BagToString () เพื่อต่อองค์ประกอบของกระเป๋าเข้ากับสตริง ในขณะที่เชื่อมต่อกันเราสามารถวางตัวคั่นระหว่างค่าเหล่านี้ได้ (ไม่บังคับ)
3	คอนแคท () เพื่อเชื่อมนิพจน์ประเภทเดียวกันสองรายการขึ้นไปเข้าด้วยกัน
4	นับ() เพื่อรับจำนวนองค์ประกอบในกระเป๋าในขณะที่นับจำนวนสิ่งที่มีในกระเป๋า
5	COUNT_STAR () มันคล้ายกับไฟล์ COUNT()ฟังก์ชัน ใช้เพื่อรับจำนวนองค์ประกอบในกระเป๋า
6	DIFF () เพื่อเปรียบเทียบกระเป๋าสองใบ (ช่อง) ในทูเพิล
7	มันว่างเปล่า() เพื่อตรวจสอบว่ากระเป๋าหรือแผนที่ว่างเปล่า
8	สูงสุด () ในการคำนวณค่าสูงสุดสำหรับคอลัมน์ (ค่าตัวเลขหรืออักขระ) ในถุงคอลัมน์เดียว
9	นาที() เพื่อให้ได้ค่าต่ำสุด (ต่ำสุด) (ตัวเลขหรืออักขระอักขระ) สำหรับคอลัมน์หนึ่งในกระเป๋าคอลัมน์เดียว
10	PluckTuple () ใช้ Pig Latin PluckTuple() เราสามารถกำหนดสตริงคำนำหน้าและกรองคอลัมน์ตามความสัมพันธ์ที่ขึ้นต้นด้วยคำนำหน้าที่กำหนด
11	ขนาด() เพื่อคำนวณจำนวนองค์ประกอบตามประเภทข้อมูล Pig
12	ย่อย () เพื่อลบสองถุง ใช้เวลาสองถุงเป็นปัจจัยการผลิตและส่งคืนกระเป๋าที่มีสิ่งทอของถุงแรกที่ไม่ได้อยู่ในถุงที่สอง
13	SUM () เพื่อรับค่าตัวเลขทั้งหมดของคอลัมน์ในกระเป๋าคอลัมน์เดียว
14	TOKENIZE () หากต้องการแยกสตริง (ซึ่งมีกลุ่มคำ) ในทูเพิลเดียวและส่งคืนกระเป๋าที่มีเอาต์พุตของการดำเนินการแยก

Load และ Storeฟังก์ชันใน Apache Pig ใช้เพื่อกำหนดว่าข้อมูลจะออกมาจาก Pig อย่างไร ฟังก์ชันเหล่านี้ใช้กับตัวดำเนินการโหลดและจัดเก็บ ด้านล่างนี้เป็นรายการฟังก์ชันการโหลดและการจัดเก็บที่มีอยู่ใน Pig

SN	ฟังก์ชั่นและคำอธิบาย
1	PigStorage () เพื่อโหลดและจัดเก็บไฟล์ที่มีโครงสร้าง
2	TextLoader () ในการโหลดข้อมูลที่ไม่มีโครงสร้างลงใน Pig
3	BinStorage () ในการโหลดและจัดเก็บข้อมูลลงใน Pig โดยใช้รูปแบบที่เครื่องอ่านได้
4	การจัดการกับการบีบอัด ใน Pig Latin เราสามารถโหลดและจัดเก็บข้อมูลที่บีบอัดได้

ด้านล่างคือรายการฟังก์ชัน Bag และ Tuple

SN	ฟังก์ชั่นและคำอธิบาย
1	TOBAG () ในการแปลงนิพจน์สองรายการขึ้นไปเป็นกระเป๋า
2	ด้านบน () เพื่อให้ได้อันดับต้น ๆ N tuples ของความสัมพันธ์
3	TOTUPLE () ในการแปลงนิพจน์หนึ่งหรือหลายนิพจน์เป็นทูเพิล
4	แผนที่() ในการแปลงคู่คีย์ - ค่าเป็นแผนที่

เรามีฟังก์ชัน String ต่อไปนี้ใน Apache Pig

SN	ฟังก์ชั่นและคำอธิบาย
1	ENDSWITH (สตริง testAgainst) เพื่อตรวจสอบว่าสตริงที่ระบุลงท้ายด้วยสตริงย่อยเฉพาะหรือไม่
2	STARTSWITH (สตริงสตริงย่อย) ยอมรับพารามิเตอร์สตริงสองตัวและตรวจสอบว่าสตริงแรกเริ่มต้นด้วยสตริงที่สองหรือไม่
3	SUBSTRING (สตริง startIndex, stopIndex) ส่งคืนสตริงย่อยจากสตริงที่กำหนด
4	EqualsIgnoreCase (string1, string2) เพื่อเปรียบเทียบสอง stings โดยไม่สนใจกรณี
5	INDEXOF (สตริง, 'อักขระ', startIndex) ส่งคืนอักขระที่เกิดขึ้นครั้งแรกในสตริงค้นหาไปข้างหน้าจากดัชนีเริ่มต้น
6	LAST_INDEX_OF (นิพจน์) ส่งคืนดัชนีของการเกิดครั้งสุดท้ายของอักขระในสตริงโดยค้นหาย้อนหลังจากดัชนีเริ่มต้น
7	LCFIRST (นิพจน์) แปลงอักขระตัวแรกในสตริงเป็นตัวพิมพ์เล็ก
8	UCFIRST (นิพจน์) ส่งคืนสตริงที่มีอักขระตัวแรกที่แปลงเป็นตัวพิมพ์ใหญ่
9	UPPER (นิพจน์) UPPER (นิพจน์) ส่งคืนสตริงที่แปลงเป็นตัวพิมพ์ใหญ่
10	LOWER (นิพจน์) แปลงอักขระทั้งหมดในสตริงเป็นตัวพิมพ์เล็ก
11	REPLACE (สตริง 'oldChar', 'newChar'); เพื่อแทนที่อักขระที่มีอยู่ในสตริงด้วยอักขระใหม่
12	STRSPLIT (สตริง regex ขีด จำกัด ) เพื่อแยกสตริงรอบ ๆ การจับคู่ของนิพจน์ทั่วไปที่กำหนด
13	STRSPLITTOBAG (สตริงนิพจน์ขีด จำกัด ) คล้ายกับไฟล์ STRSPLIT() ฟังก์ชันจะแยกสตริงโดยใช้ตัวคั่นที่กำหนดและส่งคืนผลลัพธ์ในกระเป๋า
14	TRIM (นิพจน์) ส่งคืนสำเนาของสตริงที่มีการลบช่องว่างนำหน้าและต่อท้าย
15	LTRIM (นิพจน์) ส่งคืนสำเนาของสตริงที่ลบช่องว่างนำหน้า
16	RTRIM (นิพจน์) ส่งคืนสำเนาของสตริงที่ลบช่องว่างต่อท้าย

Apache Pig มีฟังก์ชันวันที่และเวลาดังต่อไปนี้ -

SN	ฟังก์ชั่นและคำอธิบาย
1	ToDate (มิลลิวินาที) ฟังก์ชันนี้ส่งคืนวัตถุวันที่และเวลาตามพารามิเตอร์ที่กำหนด ทางเลือกอื่นสำหรับฟังก์ชันนี้ ได้แก่ ToDate (iosstring), ToDate (userstring, format), ToDate (userstring, format, timezone)
2	CurrentTime () ส่งคืนวัตถุวันที่ - เวลาของเวลาปัจจุบัน
3	GetDay (วันที่และเวลา) ส่งคืนวันของเดือนจากวัตถุวันที่ - เวลา
4	GetHour (วันที่และเวลา) ส่งคืนชั่วโมงของวันจากออบเจ็กต์วันที่และเวลา
5	GetMilliSecond (วันที่และเวลา) ส่งคืนมิลลิวินาทีของวินาทีจากออบเจ็กต์วันที่และเวลา
6	GetMinute (วันที่และเวลา) ส่งคืนนาทีของชั่วโมงจากวัตถุวันที่และเวลา
7	GetMonth (วันที่และเวลา) ส่งคืนเดือนของปีจากออบเจ็กต์วันที่ - เวลา
8	GetSecond (วันที่และเวลา) ส่งคืนวินาทีของนาทีจากออบเจ็กต์วันที่และเวลา
9	GetWeek (วันที่และเวลา) ส่งคืนสัปดาห์ของปีจากออบเจ็กต์วันที่ - เวลา
10	GetWeekYear (วันที่และเวลา) ส่งกลับสัปดาห์ปีจากออบเจ็กต์วันที่ - เวลา
11	GetYear (วันที่และเวลา) ส่งคืนปีจากออบเจ็กต์วันที่ - เวลา
12	AddDuration (วันที่เวลาระยะเวลา) ส่งคืนผลลัพธ์ของวัตถุวันที่และเวลาพร้อมกับวัตถุระยะเวลา
13	SubtractDuration (วันที่และเวลาระยะเวลา) ลบวัตถุ Duration ออกจากวัตถุ Date-Time และส่งคืนผลลัพธ์
14	DaysBetween (datetime1, datetime2) ส่งคืนจำนวนวันระหว่างวัตถุวันที่และเวลาสองรายการ
15	ชั่วโมงระหว่าง (datetime1, datetime2) ส่งคืนจำนวนชั่วโมงระหว่างวัตถุวันที่และเวลาสองชิ้น
16	MilliSecondsBetween (datetime1, datetime2) ส่งคืนจำนวนมิลลิวินาทีระหว่างวัตถุวันที่และเวลาสองรายการ
17	นาทีระหว่าง (datetime1, datetime2) ส่งคืนจำนวนนาทีระหว่างวัตถุวันที่และเวลาสองชิ้น
18	MonthsBetween (datetime1, datetime2) ส่งคืนจำนวนเดือนระหว่างวัตถุวันที่และเวลาสองรายการ
19	วินาทีระหว่าง (datetime1, datetime2) ส่งคืนจำนวนวินาทีระหว่างวัตถุวันที่และเวลาสองชิ้น
20	สัปดาห์ระหว่าง (datetime1, datetime2) ส่งคืนจำนวนสัปดาห์ระหว่างวัตถุวันที่และเวลาสองรายการ
21	YearsBetween (datetime1, datetime2) ส่งคืนจำนวนปีระหว่างวัตถุวันที่และเวลาสองรายการ

เรามีฟังก์ชันคณิตศาสตร์ต่อไปนี้ใน Apache Pig -

SN	ฟังก์ชั่นและคำอธิบาย
1	ABS (นิพจน์) เพื่อให้ได้ค่าสัมบูรณ์ของนิพจน์
2	ACOS (นิพจน์) เพื่อให้ได้อาร์คโคไซน์ของนิพจน์
3	ASIN (นิพจน์) เพื่อให้ได้อาร์คไซน์ของนิพจน์
4	ATAN (นิพจน์) ฟังก์ชันนี้ใช้เพื่อรับส่วนโค้งของนิพจน์
5	CBRT (นิพจน์) ฟังก์ชันนี้ใช้เพื่อรับคิวบ์รูทของนิพจน์
6	CEIL (นิพจน์) ฟังก์ชันนี้ใช้เพื่อรับค่าของนิพจน์ที่ปัดเศษขึ้นเป็นจำนวนเต็มที่ใกล้เคียงที่สุด
7	COS (นิพจน์) ฟังก์ชันนี้ใช้เพื่อรับโคไซน์ตรีโกณมิติของนิพจน์
8	COSH (นิพจน์) ฟังก์ชันนี้ใช้เพื่อรับไฮเพอร์โบลิกโคไซน์ของนิพจน์
9	EXP (นิพจน์) ฟังก์ชันนี้ใช้เพื่อรับเลข e ของออยเลอร์ยกกำลัง x
10	FLOOR (นิพจน์) เพื่อให้ได้ค่าของนิพจน์ที่ปัดเศษลงเป็นจำนวนเต็มที่ใกล้เคียงที่สุด
11	LOG (นิพจน์) เพื่อให้ได้ลอการิทึมธรรมชาติ (ฐาน e) ของนิพจน์
12	LOG10 (นิพจน์) เพื่อรับลอการิทึมฐาน 10 ของนิพจน์
13	สุ่ม () หากต้องการรับหมายเลขสุ่มหลอก (พิมพ์สองครั้ง) มากกว่าหรือเท่ากับ 0.0 และน้อยกว่า 1.0
14	ROUND (นิพจน์) เพื่อให้ได้ค่าของนิพจน์ที่ปัดเศษเป็นจำนวนเต็ม (หากประเภทผลลัพธ์เป็นทศนิยม) หรือปัดเศษเป็นค่ายาว (หากประเภทผลลัพธ์เป็นสองเท่า)
15	SIN (นิพจน์) เพื่อรับไซน์ของนิพจน์
16	SINH (นิพจน์) เพื่อให้ได้ไฮเพอร์โบลิกไซน์ของนิพจน์
17	SQRT (นิพจน์) เพื่อให้ได้ค่ารากที่สองบวกของนิพจน์
18	TAN (นิพจน์) เพื่อให้ได้ค่าแทนเจนต์ตรีโกณมิติของมุม
19	TANH (นิพจน์) เพื่อให้ได้ไฮเพอร์โบลิกแทนเจนต์ของนิพจน์

นอกเหนือจากฟังก์ชั่นในตัว Apache Pig ยังให้การสนับสนุนที่กว้างขวางสำหรับ Uเซอร์ Defined Fการแยก (UDF's) ด้วยการใช้ UDF เหล่านี้เราสามารถกำหนดฟังก์ชันของเราเองและใช้งานได้ การสนับสนุน UDF มีให้ในหกภาษาโปรแกรม ได้แก่ Java, Jython, Python, JavaScript, Ruby และ Groovy

สำหรับการเขียน UDF การสนับสนุนที่สมบูรณ์มีให้ใน Java และการสนับสนุนที่ จำกัด มีให้ในภาษาที่เหลือทั้งหมด ด้วยการใช้ Java คุณสามารถเขียน UDF ที่เกี่ยวข้องกับทุกส่วนของการประมวลผลเช่นการโหลดข้อมูล / การจัดเก็บการแปลงคอลัมน์และการรวม เนื่องจาก Apache Pig ถูกเขียนด้วยภาษา Java การเขียนของ UDF โดยใช้ภาษา Java จึงทำงานได้อย่างมีประสิทธิภาพเมื่อเทียบกับภาษาอื่น ๆ

ใน Apache Pig เรายังมีที่เก็บ Java สำหรับชื่อ UDF Piggybank. การใช้ Piggybank เราสามารถเข้าถึง Java UDF ที่เขียนโดยผู้ใช้รายอื่นและสนับสนุน UDF ของเราเอง

ประเภทของ UDF ใน Java

ในขณะที่เขียน UDF โดยใช้ Java เราสามารถสร้างและใช้ฟังก์ชันสามประเภทต่อไปนี้ -

• Filter Functions- ฟังก์ชันตัวกรองใช้เป็นเงื่อนไขในคำสั่งตัวกรอง ฟังก์ชันเหล่านี้ยอมรับค่า Pig เป็นอินพุตและส่งคืนค่าบูลีน

• Eval Functions- ฟังก์ชัน Eval ใช้ในคำสั่ง FOREACH-GENERATE ฟังก์ชันเหล่านี้ยอมรับค่า Pig เป็นอินพุตและส่งคืนผลลัพธ์ Pig

• Algebraic Functions- ฟังก์ชันพีชคณิตทำหน้าที่กับกระเป๋าชั้นในในคำสั่ง FOREACHGENERATE ฟังก์ชันเหล่านี้ใช้เพื่อดำเนินการ MapReduce เต็มรูปแบบบนกระเป๋าด้านใน

การเขียน UDF โดยใช้ Java

ในการเขียน UDF โดยใช้ Java เราต้องรวมไฟล์ jar Pig-0.15.0.jar. ในส่วนนี้เราจะพูดถึงวิธีการเขียน UDF ตัวอย่างโดยใช้ Eclipse ก่อนดำเนินการเพิ่มเติมตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Eclipse และ Maven ในระบบของคุณแล้ว

ทำตามขั้นตอนด้านล่างเพื่อเขียนฟังก์ชัน UDF -

• เปิด Eclipse และสร้างโครงการใหม่ (พูด myproject).

• แปลงโครงการที่สร้างขึ้นใหม่เป็นโครงการ Maven

• คัดลอกเนื้อหาต่อไปนี้ใน pom.xml ไฟล์นี้มีการอ้างอิง Maven สำหรับไฟล์ jar Apache Pig และ Hadoop-core

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0http://maven.apache .org/xsd/maven-4.0.0.xsd"> 
	
   <modelVersion>4.0.0</modelVersion> 
   <groupId>Pig_Udf</groupId> 
   <artifactId>Pig_Udf</artifactId> 
   <version>0.0.1-SNAPSHOT</version>
	
   <build>    
      <sourceDirectory>src</sourceDirectory>    
      <plugins>      
         <plugin>        
            <artifactId>maven-compiler-plugin</artifactId>        
            <version>3.3</version>        
            <configuration>          
               <source>1.7</source>          
               <target>1.7</target>        
            </configuration>      
         </plugin>    
      </plugins>  
   </build>
	
   <dependencies> 
	
      <dependency>            
         <groupId>org.apache.pig</groupId>            
         <artifactId>pig</artifactId>            
         <version>0.15.0</version>     
      </dependency> 
		
      <dependency>        
         <groupId>org.apache.hadoop</groupId>            
         <artifactId>hadoop-core</artifactId>            
         <version>0.20.2</version>     
      </dependency> 
      
   </dependencies>  
	
</project>

• บันทึกไฟล์และรีเฟรช ในMaven Dependencies คุณจะพบไฟล์ jar ที่ดาวน์โหลดมา

• สร้างไฟล์คลาสใหม่ด้วยชื่อ Sample_Eval และคัดลอกเนื้อหาต่อไปนี้ในนั้น

import java.io.IOException; 
import org.apache.pig.EvalFunc; 
import org.apache.pig.data.Tuple; 
 
import java.io.IOException; 
import org.apache.pig.EvalFunc; 
import org.apache.pig.data.Tuple;

public class Sample_Eval extends EvalFunc<String>{ 

   public String exec(Tuple input) throws IOException {   
      if (input == null || input.size() == 0)      
      return null;      
      String str = (String)input.get(0);      
      return str.toUpperCase();  
   } 
}

ในขณะที่เขียน UDF จำเป็นต้องสืบทอดคลาส EvalFunc และจัดเตรียมการนำไปใช้งาน exec()ฟังก์ชัน ภายในฟังก์ชันนี้รหัสที่จำเป็นสำหรับ UDF จะถูกเขียนขึ้น ในตัวอย่างข้างต้นเราได้ส่งคืนโค้ดเพื่อแปลงเนื้อหาของคอลัมน์ที่กำหนดให้เป็นตัวพิมพ์ใหญ่

• หลังจากรวบรวมคลาสโดยไม่มีข้อผิดพลาดให้คลิกขวาที่ไฟล์ Sample_Eval.java จะให้เมนู เลือกexport ดังที่แสดงในภาพหน้าจอต่อไปนี้

• เมื่อคลิก exportคุณจะได้รับหน้าต่างดังต่อไปนี้ คลิกที่JAR file.

• ดำเนินการต่อไปโดยคลิก Next>ปุ่ม. คุณจะได้รับหน้าต่างอื่นที่คุณต้องเข้าสู่เส้นทางในระบบไฟล์ภายในซึ่งคุณต้องจัดเก็บไฟล์ jar

• สุดท้ายคลิกไฟล์ Finishปุ่ม. ในโฟลเดอร์ที่ระบุไฟล์ Jarsample_udf.jarถูกสร้างขึ้น ไฟล์ jar นี้มี UDF ที่เขียนด้วย Java

การใช้ UDF

หลังจากเขียน UDF และสร้างไฟล์ Jar แล้วให้ทำตามขั้นตอนด้านล่าง -

ขั้นตอนที่ 1: การลงทะเบียนไฟล์ Jar

หลังจากเขียน UDF (ใน Java) เราต้องลงทะเบียนไฟล์ Jar ที่มี UDF โดยใช้ตัวดำเนินการ Register เมื่อลงทะเบียนไฟล์ Jar ผู้ใช้สามารถกำหนดตำแหน่งของ UDF กับ Apache Pig ได้อย่างใกล้ชิด

Syntax

ด้านล่างเป็นไวยากรณ์ของตัวดำเนินการ Register

REGISTER path;

Example

ตัวอย่างเช่นให้เราลงทะเบียน sample_udf.jar ที่สร้างขึ้นก่อนหน้านี้ในบทนี้

เริ่มต้น Apache Pig ในโหมดโลคัลและลงทะเบียนไฟล์ jar sample_udf.jar ดังที่แสดงด้านล่าง

$cd PIG_HOME/bin $./pig –x local 

REGISTER '/$PIG_HOME/sample_udf.jar'

Note - ถือว่าไฟล์ Jar ในพา ธ - /$PIG_HOME/sample_udf.jar

ขั้นตอนที่ 2: การกำหนดนามแฝง

หลังจากลงทะเบียน UDF แล้วเราสามารถกำหนดนามแฝงได้โดยใช้ Define ตัวดำเนินการ

Syntax

ด้านล่างคือไวยากรณ์ของตัวดำเนินการกำหนด

DEFINE alias {function | [`command` [input] [output] [ship] [cache] [stderr] ] };

Example

กำหนดนามแฝงสำหรับ sample_eval ดังที่แสดงด้านล่าง

DEFINE sample_eval sample_eval();

ขั้นตอนที่ 3: การใช้ UDF

หลังจากกำหนดนามแฝงแล้วคุณสามารถใช้ UDF เหมือนกับฟังก์ชันในตัว สมมติว่ามีไฟล์ชื่อ emp_data ใน HDFS/Pig_Data/ ไดเรกทอรีที่มีเนื้อหาต่อไปนี้

001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork
008,Syam,23,Kolkata
009,Mary,25,Tokyo
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai

และสมมติว่าเราได้โหลดไฟล์นี้ลงใน Pig ตามที่แสดงด้านล่าง

grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp1.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);

ตอนนี้ให้เราแปลงชื่อของพนักงานเป็นตัวพิมพ์ใหญ่โดยใช้ UDF sample_eval.

grunt> Upper_case = FOREACH emp_data GENERATE sample_eval(name);

ตรวจสอบเนื้อหาของความสัมพันธ์ Upper_case ดังแสดงด้านล่าง

grunt> Dump Upper_case;
  
(ROBIN)
(BOB)
(MAYA)
(SARA)
(DAVID)
(MAGGY)
(ROBERT)
(SYAM)
(MARY)
(SARAN)
(STACY)
(KELLY)

ในบทนี้เราจะดูวิธีเรียกใช้สคริปต์ Apache Pig ในโหมดแบทช์

ความคิดเห็นในคริปหมู

ในขณะที่เขียนสคริปต์ในไฟล์เราสามารถรวมความคิดเห็นไว้ในนั้นได้ดังที่แสดงด้านล่าง

ความคิดเห็นหลายบรรทัด

เราจะเริ่มความคิดเห็นหลายบรรทัดด้วย '/ *' และลงท้ายด้วย '* /'

/* These are the multi-line comments 
  In the pig script */

ความคิดเห็นบรรทัดเดียว

เราจะเริ่มต้นความคิดเห็นบรรทัดเดียวด้วย "-"

--we can write single line comments like this.

การเรียกใช้ Pig Script ในโหมด Batch

ขณะดำเนินการคำสั่ง Apache Pig ในโหมดแบตช์ให้ทำตามขั้นตอนด้านล่าง

ขั้นตอนที่ 1

เขียนคำสั่ง Pig Latin ที่จำเป็นทั้งหมดในไฟล์เดียว เราสามารถเขียนคำสั่งและคำสั่ง Pig Latin ทั้งหมดในไฟล์เดียวและบันทึกเป็นไฟล์.pig ไฟล์.

ขั้นตอนที่ 2

เรียกใช้สคริปต์ Apache Pig คุณสามารถรันสคริปต์ Pig ได้จากเชลล์ (Linux) ดังที่แสดงด้านล่าง

โหมดท้องถิ่น	โหมด MapReduce
$ หมู -x ท้องถิ่น Sample_script.pig	$ หมู -x mapreduce Sample_script.pig

คุณสามารถเรียกใช้งานได้จาก Grunt shell เช่นกันโดยใช้คำสั่ง exec ดังที่แสดงด้านล่าง

grunt> exec /sample_script.pig

การเรียกใช้ Pig Script จาก HDFS

นอกจากนี้เรายังสามารถเรียกใช้สคริปต์ Pig ที่อยู่ใน HDFS สมมติว่ามีสคริปต์หมูที่มีชื่อSample_script.pig ในไดเร็กทอรี HDFS ชื่อ /pig_data/. เราสามารถดำเนินการได้ดังที่แสดงด้านล่าง

$ pig -x mapreduce hdfs://localhost:9000/pig_data/Sample_script.pig

ตัวอย่าง

สมมติว่าเรามีไฟล์ student_details.txt ใน HDFS ที่มีเนื้อหาต่อไปนี้

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad 
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

เรายังมีตัวอย่างสคริปต์ที่มีชื่อ sample_script.pigในไดเร็กทอรี HDFS เดียวกัน ไฟล์นี้มีคำสั่งที่ดำเนินการและการแปลงไฟล์student ความสัมพันธ์ดังที่แสดงด้านล่าง

student = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);
	
student_order = ORDER student BY age DESC;
  
student_limit = LIMIT student_order 4;
  
Dump student_limit;

• คำสั่งแรกของสคริปต์จะโหลดข้อมูลในไฟล์ชื่อ student_details.txt เป็นความสัมพันธ์ที่มีชื่อว่า student.

• คำสั่งที่สองของสคริปต์จะจัดเรียงทูเปิลของความสัมพันธ์ตามลำดับจากมากไปหาน้อยตามอายุและจัดเก็บเป็น student_order.

• คำสั่งที่สามของสคริปต์จะจัดเก็บ 4 อันดับแรกของ student_order เช่น student_limit.

• ในที่สุดคำสั่งที่สี่จะถ่ายโอนเนื้อหาของความสัมพันธ์ student_limit.

ตอนนี้ให้เราดำเนินการ sample_script.pig ดังแสดงด้านล่าง

$./pig -x mapreduce hdfs://localhost:9000/pig_data/sample_script.pig

Apache Pig ได้รับการดำเนินการและให้ผลลัพธ์ที่มีเนื้อหาต่อไปนี้

(7,Komal,Nayak,24,9848022334,trivendram)
(8,Bharathi,Nambiayar,24,9848022333,Chennai) 
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar) 
(6,Archana,Mishra,23,9848022335,Chennai)
2015-10-19 10:31:27,446 [main] INFO  org.apache.pig.Main - Pig script completed in 12
minutes, 32 seconds and 751 milliseconds (752751 ms)