दिलचस्प पोस्ट
ईजेबी का इस्तेमाल करते समय, प्रत्येक प्रबंधित बीन को ईजेबी की अपनी स्वयं की जानकारी मिलती है? सॉर्ट किए गए मैट्रिक्स पर चयन एल्गोरिदम डिफ़ॉल्ट ऑब्जेक्ट.स्टोस्टिंग () क्यों हैशोड में शामिल है? जावास्क्रिप्ट बिना jQuery के स्लाइडेउन क्या जिथूब को जावास्क्रिप्ट पुस्तकालयों के लिए सीडीएन के रूप में इस्तेमाल किया जाना चाहिए? मुख्य गतिविधि के लिए OnPostExecute () का नतीजा कैसे प्राप्त करें क्योंकि AsyncTask एक अलग वर्ग है? मेवेन में जावा_होम AddEventListener श्रोता फ़ंक्शन को जोड़ने के लिए तर्क कैसे पास करें? घटकों को जोड़ने से पहले मुझे क्यों नहीं सेट करना चाहिए (सच है)? एपीआई कुंजी को उजागर करें एंड्रॉइड वेबव्यू ने उपयोगकर्ता इनपुट को क्यों नकार दिया? मैं Rails में database.yml फ़ाइल को कैसे स्थापित कर सकता हूं? संख्यात्मक कीपैड के लिए कुंजी कोड मान? क्या मैं PHPUnit में "नकली" समय सकता हूँ? वीसी + + घातक त्रुटि LNK1168: लिखने के लिए filename.exe खोल नहीं सकता

जटिल प्रकारों के साथ स्पार्क एसक्यूएल डाटाफ़्रेम पूछताछ करना

मैक्स / एरेज़ जैसे जटिल प्रकारों के साथ आरडीडी कैसे पूछ सकता हूँ? उदाहरण के लिए, जब मैं यह परीक्षण कोड लिख रहा था:

case class Test(name: String, map: Map[String, String]) val map = Map("hello" -> "world", "hey" -> "there") val map2 = Map("hello" -> "people", "hey" -> "you") val rdd = sc.parallelize(Array(Test("first", map), Test("second", map2))) 

हालांकि, सिंटैक्स कुछ ऐसा होगा:

 sqlContext.sql("SELECT * FROM rdd WHERE map.hello = world") 

या

 sqlContext.sql("SELECT * FROM rdd WHERE map[hello] = world") 

लेकिन मुझे मिल रहा है

नेस्टेड फ़ील्ड में मानचित्र प्रकार टाइप नहीं कर सकते (स्ट्रिंग टाईप, स्ट्रिंग टाइप, सच)

तथा

org.apache.spark.sql.catalyst.errors.package $ TreeNodeException: अनसोल एट्रिब्यूट्स

क्रमशः।

Solutions Collecting From Web of "जटिल प्रकारों के साथ स्पार्क एसक्यूएल डाटाफ़्रेम पूछताछ करना"

यह स्तंभ के एक प्रकार पर निर्भर करता है। चलो कुछ डमी डेटा से शुरू करें:

 import org.apache.spark.sql.functions.{udf, lit} import scala.util.Try case class SubRecord(x: Int) case class ArrayElement(foo: String, bar: Int, vals: Array[Double]) case class Record( an_array: Array[Int], a_map: Map[String, String], a_struct: SubRecord, an_array_of_structs: Array[ArrayElement]) val df = sc.parallelize(Seq( Record(Array(1, 2, 3), Map("foo" -> "bar"), SubRecord(1), Array( ArrayElement("foo", 1, Array(1.0, 2.0)), ArrayElement("bar", 2, Array(3.0, 4.0)))), Record(Array(4, 5, 6), Map("foz" -> "baz"), SubRecord(2), Array(ArrayElement("foz", 3, Array(5.0, 6.0)), ArrayElement("baz", 4, Array(7.0, 8.0)))) )).toDF 
 df.registerTempTable("df") df.printSchema // root // |-- an_array: array (nullable = true) // | |-- element: integer (containsNull = false) // |-- a_map: map (nullable = true) // | |-- key: string // | |-- value: string (valueContainsNull = true) // |-- a_struct: struct (nullable = true) // | |-- x: integer (nullable = false) // |-- an_array_of_structs: array (nullable = true) // | |-- element: struct (containsNull = true) // | | |-- foo: string (nullable = true) // | | |-- bar: integer (nullable = false) // | | |-- vals: array (nullable = true) // | | | |-- element: double (containsNull = false) 
  • सरणी स्तंभ:

    • Column.getItem विधि

       df.select($"an_array".getItem(1)).show // +-----------+ // |an_array[1]| // +-----------+ // | 2| // | 5| // +-----------+ 
    • हाइव ब्रैकेट सिंटैक्स:

       sqlContext.sql("SELECT an_array[1] FROM df").show // +---+ // |_c0| // +---+ // | 2| // | 5| // +---+ 
    • एक यूडीएफ

       val get_ith = udf((xs: Seq[Int], i: Int) => Try(xs(i)).toOption) df.select(get_ith($"an_array", lit(1))).show // +---------------+ // |UDF(an_array,1)| // +---------------+ // | 2| // | 5| // +---------------+ 
  • नक्शा स्तंभ

    • Column.getField विधि का उपयोग कर:

       df.select($"a_map".getField("foo")).show // +----------+ // |a_map[foo]| // +----------+ // | bar| // | null| // +----------+ 
    • हाइव ब्रैकेट सिंटैक्स का उपयोग कर:

       sqlContext.sql("SELECT a_map['foz'] FROM df").show // +----+ // | _c0| // +----+ // |null| // | baz| // +----+ 
    • डॉट सिंटैक्स के साथ पूर्ण पथ का उपयोग करना:

       df.select($"a_map.foo").show // +----+ // | foo| // +----+ // | bar| // |null| // +----+ 
    • यूडीएफ का उपयोग कर

       val get_field = udf((kvs: Map[String, String], k: String) => kvs.get(k)) df.select(get_field($"a_map", lit("foo"))).show // +--------------+ // |UDF(a_map,foo)| // +--------------+ // | bar| // | null| // +--------------+ 
  • डॉट सिंटैक्स के साथ पूर्ण पथ का उपयोग कर संरचना कॉलम:

    • डेटाफ्रेम एपीआई के साथ

       df.select($"a_struct.x").show // +---+ // | x| // +---+ // | 1| // | 2| // +---+ 
    • कच्चे एसक्यूएल के साथ

       sqlContext.sql("SELECT a_struct.x FROM df").show // +---+ // | x| // +---+ // | 1| // | 2| // +---+ 
  • structs -सिंटैक्स, नामों और मानक Column तरीकों का उपयोग करके structs सरणी के भीतर फ़ील्ड तक पहुंचा जा सकता है:

     df.select($"an_array_of_structs.foo").show // +----------+ // | foo| // +----------+ // |[foo, bar]| // |[foz, baz]| // +----------+ sqlContext.sql("SELECT an_array_of_structs[0].foo FROM df").show // +---+ // |_c0| // +---+ // |foo| // |foz| // +---+ df.select($"an_array_of_structs.vals".getItem(1).getItem(1)).show // +------------------------------+ // |an_array_of_structs.vals[1][1]| // +------------------------------+ // | 4.0| // | 8.0| // +------------------------------+ 
  • उपयोगकर्ता परिभाषित प्रकार (यूडीटी) फ़ील्ड यूडीएफ के जरिये एक्सेस किए जा सकते हैं। विस्तृत जानकारी के लिए यूडीटी के स्पार्कस्यूएल संदर्भों को देखें।

नोट्स :

  • स्पार्क संस्करण के आधार पर इन तरीकों में से कुछ केवल HiveContext साथ उपलब्ध हो सकते हैं। यूडीएफ को मानक SQLContext और HiveContext SQLContext दोनों के साथ संस्करण से स्वतंत्र रूप से काम करना चाहिए।
  • आम तौर पर नेस्टेड मान एक द्वितीय श्रेणी वाले नागरिक हैं नेस्टेड क्षेत्रों पर सभी विशिष्ट संचालन समर्थित नहीं हैं। एक संदर्भ के आधार पर स्कीमा को समतल करना और / या संग्रह विस्फोट करना बेहतर हो सकता है

     df.select(explode($"an_array_of_structs")).show // +--------------------+ // | col| // +--------------------+ // |[foo,1,WrappedArr...| // |[bar,2,WrappedArr...| // |[foz,3,WrappedArr...| // |[baz,4,WrappedArr...| // +--------------------+ 
  • डॉट सिंटैक्स को वाइल्डकार्ड वर्ण ( * ) के साथ संयोजित किया जा सकता है (संभवतः कई) क्षेत्रों को स्पष्ट रूप से निर्दिष्ट किए बिना:

     df.select($"a_struct.*").show // +---+ // | x| // +---+ // | 1| // | 2| // +---+ 

एक बार जब आप इसे डीएफ में बदलते हैं, तो आप बस डेटा को उतना ही ला सकते हैं

  val rddRow= rdd.map(kv=>{ val k = kv._1 val v = kv._2 Row(k, v) }) val myFld1 = StructField("name", org.apache.spark.sql.types.StringType, true) val myFld2 = StructField("map", org.apache.spark.sql.types.MapType(StringType, StringType), true) val arr = Array( myFld1, myFld2) val schema = StructType( arr ) val rowrddDF = sqc.createDataFrame(rddRow, schema) rowrddDF.registerTempTable("rowtbl") val rowrddDFFinal = rowrddDF.select(rowrddDF("map.one")) or val rowrddDFFinal = rowrddDF.select("map.one") 

यहाँ मैं क्या किया और यह काम किया था

 case class Test(name: String, m: Map[String, String]) val map = Map("hello" -> "world", "hey" -> "there") val map2 = Map("hello" -> "people", "hey" -> "you") val rdd = sc.parallelize(Array(Test("first", map), Test("second", map2))) val rdddf = rdd.toDF rdddf.registerTempTable("mytable") sqlContext.sql("select m.hello from mytable").show 

परिणाम

 +------+ | hello| +------+ | world| |people| +------+