ฟังก์ชัน Hive: ฟังก์ชันในตัวและฟังก์ชันที่ผู้ใช้กำหนดเอง (UDF) ตัวอย่าง

ฟังก์ชันถูกสร้างขึ้นเพื่อวัตถุประสงค์เฉพาะ เพื่อดำเนินการต่างๆ เช่น การคำนวณทางคณิตศาสตร์ เลขคณิต ตรรกะ และความสัมพันธ์ บนตัวถูกดำเนินการของชื่อคอลัมน์ในตาราง

ฟังก์ชั่นในตัว

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

มีการกล่าวถึงรูปแบบและประเภทต่างๆ ในส่วนต่อไปนี้

ประเภทของฟังก์ชันในตัวของ Hive:

• ฟังก์ชั่นการรวบรวม
• ฟังก์ชั่นวันที่
• ฟังก์ชันทางคณิตศาสตร์
• ฟังก์ชันแบบมีเงื่อนไข
• ฟังก์ชันสตริง
• อื่น ๆ. ฟังก์ชั่น

แต่ละตระกูลทั้งหกตระกูลจะได้รับการอธิบายโดยละเอียดด้านล่าง พร้อมทั้งรูปแบบการใช้งานและประเภทค่าส่งกลับ

ฟังก์ชั่นการรวบรวม

ฟังก์ชันเหล่านี้ใช้สำหรับคอลเลกชัน คอลเลกชันหมายถึงกลุ่มping ประกอบด้วยองค์ประกอบหลายรายการ และจะส่งคืนองค์ประกอบเดียวหรืออาร์เรย์ขององค์ประกอบ ขึ้นอยู่กับประเภทการส่งคืนที่ระบุไว้ในชื่อฟังก์ชัน

ฟังก์ชั่นวันที่

ฟังก์ชันเหล่านี้ใช้สำหรับจัดการข้อมูลวันที่และแปลงประเภทข้อมูลวันที่จากประเภทหนึ่งไปเป็นอีกประเภทหนึ่ง:

ฟังก์ชันทางคณิตศาสตร์

ฟังก์ชันเหล่านี้ใช้สำหรับการคำนวณทางคณิตศาสตร์ แทนที่จะสร้าง UDF (User-Defined Functions) เรามีฟังก์ชันทางคณิตศาสตร์ที่สร้างไว้แล้วใน Hive

ฟังก์ชันแบบมีเงื่อนไข

ฟังก์ชันเหล่านี้ใช้สำหรับการตรวจสอบค่าแบบมีเงื่อนไข

ฟังก์ชันสตริง

การจัดการและการดำเนินการกับสตริงจะดำเนินการโดยฟังก์ชันต่อไปนี้

อื่น ๆ. ฟังก์ชั่น

ฟังก์ชันในตัวหลายฟังก์ชันไม่ได้จัดอยู่ในตระกูลใดๆ ข้างต้น ฟังก์ชันเหล่านี้ครอบคลุมถึงการแฮช ข้อมูลเซสชัน และการเรียกใช้ฟังก์ชันตามอำเภอใจ Java วิธีการ

UDF (ฟังก์ชันที่ผู้ใช้กำหนด)

ใน Hive ผู้ใช้สามารถกำหนดฟังก์ชันของตนเองเพื่อตอบสนองความต้องการของไคลเอ็นต์บางอย่างได้ ฟังก์ชันเหล่านี้เรียกว่า UDF ใน Hive ฟังก์ชันที่ผู้ใช้กำหนดเองเขียนด้วยภาษา Hive Java สำหรับโมดูลเฉพาะ

ฟังก์ชันที่ผู้ใช้กำหนดเอง (UDF) บางตัวได้รับการออกแบบมาโดยเฉพาะเพื่อการนำโค้ดกลับมาใช้ซ้ำในเฟรมเวิร์กของแอปพลิเคชัน นักพัฒนาเป็นผู้เขียนฟังก์ชันเหล่านี้ขึ้นมาเอง Java และผสานรวม UDF เหล่านั้นเข้ากับ Hive

ระหว่างการประมวลผลคำสั่งค้นหา นักพัฒนาสามารถใช้โค้ดได้โดยตรง และ UDF จะส่งคืนผลลัพธ์ตามงานที่ผู้ใช้กำหนด ซึ่งให้ประสิทธิภาพสูงทั้งในด้านการเขียนโค้ดและการประมวลผล

ตัวอย่างเช่น สำหรับการตัดคำในสตริง เราไม่มีฟังก์ชันที่กำหนดไว้ล่วงหน้าใน Hive ดังนั้นเราจึงสามารถเขียนฟังก์ชัน UDF สำหรับการตัดคำได้เอง Java. เมื่อใดก็ตามที่เราต้องการฟังก์ชันการทำงานของ stem เราสามารถเรียกใช้ UDF ของ stem นี้ได้โดยตรงใน Hive

ในที่นี้ ฟังก์ชันการตัดคำหมายถึงการสร้างคำจากรากศัพท์ อัลกอริทึมการตัดคำจะลดคำว่า “wishing”, “wished” และ “wishes” ให้เหลือเพียงรากศัพท์ “wish” ในการทำงานประเภทนี้ เราสามารถเขียน UDF ได้ใน Java และบูรณาการเข้ากับ รัง.

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

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

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

UDF ปะทะ UDAF ปะทะ UDTF ใน Hive

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

จากตารางนี้สามารถสรุปเป็นกฎปฏิบัติสองข้อได้ดังนี้:

• โดยทั่วไปแล้ว UDAF มักจะใช้คู่กับคำสั่ง GROUP BY เสมอ เพราะมันจะยุบแต่ละกลุ่มให้เหลือเพียงแถวเดียว
• ไม่สามารถเลือก UDTF ร่วมกับคอลัมน์อื่นๆ ในรายการ SELECT เดียวกันได้ ดังนั้นโดยปกติจึงใช้ร่วมกับ LATERAL VIEW

นอกจากนี้ยังมีคลาสพื้นฐานที่สองซึ่งมีความสามารถมากกว่าสำหรับการทำงานในระดับแถว นั่นคือ GenericUDF ซึ่งรับประเภทข้อมูลที่ซับซ้อน เช่น อาร์เรย์ แผนที่ และโครงสร้าง รวมถึงจำนวนอาร์กิวเมนต์ที่เปลี่ยนแปลงได้

วิธีการเขียนและลงทะเบียน UDF ใน Hive

ตัวอย่างลำต้นที่อธิบายไว้ข้างต้นสามารถสร้างเป็นฟังก์ชันจริงได้ในสี่ขั้นตอน ไม่มีอะไรมากไปกว่านั้น Java จำเป็นต้องมีคอมไพเลอร์และเซสชัน Hive ที่กำลังทำงานอยู่

ขั้นตอน 1) เขียนถึง Java คลาสที่สืบทอดมาจาก UDF และใช้งานเมธอดสาธารณะ evaluate() Hive จะเรียก evaluate() หนึ่งครั้งต่อแถว ดังนั้นเมธอดนี้ต้องรองรับค่า NULL ได้

package com.guru99.hive.udf;

import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;

public final class Stem extends UDF {

    public Text evaluate(final Text input) {
        if (input == null) {
            return null;
        }
        String word = input.toString().toLowerCase();
        if (word.endsWith("ing")) {
            word = word.substring(0, word.length() - 3);
        } else if (word.endsWith("ed") || word.endsWith("es")) {
            word = word.substring(0, word.length() - 2);
        }
        return new Text(word);
    }
}

ขั้นตอน 2) คอมไพล์คลาสและบรรจุลงในไฟล์ JAR เช่น hive-udf-1.0.jar พร้อมกับคลาสอื่นๆ ที่คลาสนี้ขึ้นอยู่ด้วย

ขั้นตอน 3) เพิ่มไฟล์ JAR ลงใน classpath ของ Hive และผูกชื่อฟังก์ชันเข้ากับคลาส ฟังก์ชันชั่วคราวจะมีอายุใช้งานเฉพาะในเซสชันปัจจุบันเท่านั้น

ADD JAR /home/hduser/hive-udf-1.0.jar;

CREATE TEMPORARY FUNCTION stem AS 'com.guru99.hive.udf.Stem';

ขั้นตอน 4) เรียกใช้ฟังก์ชันใหม่นี้เหมือนกับฟังก์ชันพื้นฐานทั่วไป เมื่อนำไปใช้กับคำว่า “wishing”, “wished” และ “wishes” คลาสนี้จะคืนค่า “wish” สำหรับทั้งสามคำ

SELECT word, stem(word) FROM words;

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

CREATE FUNCTION default.stem AS 'com.guru99.hive.udf.Stem'
USING JAR '/user/hive/udfs/hive-udf-1.0.jar';

คลาสเดียวอาจประกาศเมธอด evaluate() ได้มากกว่าหนึ่งเมธอด Hive จะตรวจสอบการเรียกใช้กับรูปแบบของอาร์กิวเมนต์ ซึ่งเป็นเหตุผลว่าทำไมฟังก์ชันหนึ่งจึงสามารถรับได้ทั้งสตริงและจำนวนเต็ม

คำถามที่พบบ่อย