क्या collect_list() पंक्तियों के सापेक्ष क्रम को बनाए रखता है?

Question

कल्पना कीजिए कि मैं निम्नलिखित DataFrame df है:

+---+-----------+------------+ 
| id|featureName|featureValue| 
+---+-----------+------------+ 
|id1|   a|   3| 
|id1|   b|   4| 
|id2|   a|   2| 
|id2|   c|   5| 
|id3|   d|   9| 
+---+-----------+------------+ 

कल्पना कीजिए कि मैं चलाएँ:

df.groupBy("id") 
    .agg(collect_list($"featureIndex").as("idx"), 
     collect_list($"featureValue").as("val")) 

हूँ मैं गारंटी कि "IDX" और "वैल" समग्र किया जाएगा और उनके रिश्तेदार रखना आदेश? यानी

GOOD     GOOD     BAD 
+---+------+------+ +---+------+------+ +---+------+------+ 
| id| idx| val| | id| idx| val| | id| idx| val| 
+---+------+------+ +---+------+------+ +---+------+------+ 
|id3| [d]| [9]| |id3| [d]| [9]| |id3| [d]| [9]| 
|id1|[a, b]|[3, 4]| |id1|[b, a]|[4, 3]| |id1|[a, b]|[4, 3]| 
|id2|[a, c]|[2, 5]| |id2|[c, a]|[5, 2]| |id2|[a, c]|[5, 2]| 
+---+------+------+ +---+------+------+ +---+------+------+ 

नोट: उदा। यह बीएडी है क्योंकि आईडी 1 [ए, बी] के लिए [3, 4] (और नहीं [4, 3]) से जुड़ा होना चाहिए था। आईडी 2

Answer 1

के लिए एक ही मुझे लगता है कि आप के रूप में स्पार्क क्रम में एक के बाद एक (और आमतौर पर नहीं है फिर से आदेश पंक्तियों यदि स्पष्ट रूप से की जरूरत नहीं) पंक्तियों पर चला जाता है पर "उनके रिश्तेदार आदेश" भरोसा कर सकते हैं।

यदि आप आदेश से चिंतित हैं, तो groupBy करने से पहले struct फ़ंक्शन का उपयोग करके इन दो कॉलम को मर्ज करें।

struct (colName: स्ट्रिंग, colNames: स्ट्रिंग *): स्तंभ एक नया struct स्तंभ एकाधिक इनपुट कॉलम तैयार करता बनाता है।

तुम भी संख्या रिकॉर्ड के monotonically_increasing_id समारोह का उपयोग करें और इसका इस्तेमाल अन्य स्तंभों (शायद struct का प्रयोग करके) के साथ जोड़ी बनाने सकता है:

monotonically_increasing_id(): स्तंभ एक स्तंभ अभिव्यक्ति है कि होगा- उत्पन्न बढ़ रही है 64-बिट पूर्णांक।

जेनरेट आईडी को एकनिष्ठ रूप से बढ़ने और अद्वितीय होने की गारंटी है, लेकिन लगातार नहीं।