Spark-sql-row

@(spark)[sql|row]

Row

row就是关系数据库中的一行。

/**                                                                                                                                                                      * Represents one row of output from a relational operator.  Allows both generic access by ordinal,                                                                      * which will incur boxing overhead for primitives, as well as native primitive access.                                                                                  *                                                                                                                                                                       * It is invalid to use the native primitive interface to retrieve a value that is null, instead a                                                                       * user must check `isNullAt` before attempting to retrieve a value that might be null.                                                                                  *                                                                                                                                                                       * To create a new Row, use [[RowFactory.create()]] in Java or [[Row.apply()]] in Scala.                                                                                 *                                                                                                                                                                       * A [[Row]] object can be constructed by providing field values. Example:                                                                                               * {{{                                                                                                                                                                   * import org.apache.spark.sql._                                                                                                                                         *                                                                                                                                                                       * // Create a Row from values.                                                                                                                                          * Row(value1, value2, value3, ...)                                                                                                                                      * // Create a Row from a Seq of values.                                                                                                                                 * Row.fromSeq(Seq(value1, value2, ...))                                                                                                                                 * }}}                                                                                                                                                                   *                                                                                                                                                                       * A value of a row can be accessed through both generic access by ordinal,                                                                                              * which will incur boxing overhead for primitives, as well as native primitive access.                                                                                  * An example of generic access by ordinal:                                                                                                                              * {{{                                                                                                                                                                   * import org.apache.spark.sql._                                                                                                                                         *                                                                                                                                                                       * val row = Row(1, true, "a string", null)                                                                                                                              * // row: Row = [1,true,a string,null]                                                                                                                                  * val firstValue = row(0)      * // firstValue: Any = 1                                                                                                                                                * val fourthValue = row(3)                                                                                                                                              * // fourthValue: Any = null                                                                                                                                            * }}}                                                                                                                                                                   *                                                                                                                                                                       * For native primitive access, it is invalid to use the native primitive interface to retrieve                                                                          * a value that is null, instead a user must check `isNullAt` before attempting to retrieve a                                                                            * value that might be null.                                                                                                                                             * An example of native primitive access:                                                                                                                                * {{{                                                                                                                                                                   * // using the row from the previous example.                                                                                                                           * val firstValue = row.getInt(0)                                                                                                                                        * // firstValue: Int = 1                                                                                                                                                * val isNull = row.isNullAt(3)                                                                                                                                          * // isNull: Boolean = true                                                                                                                                             * }}}                                                                                                                                                                   *                                                                                                                                                                       * In Scala, fields in a [[Row]] object can be extracted in a pattern match. Example:                                                                                    * {{{                                                                                                                                                                   * import org.apache.spark.sql._                                                                                                                                         *                                                                                                                                                                       * val pairs = sql("SELECT key, value FROM src").rdd.map {                                                                                                               *   case Row(key: Int, value: String) =>                                                                                                                                *     key -> value                                                                                                                                                      * }                                                                                                                                                                     * }}}                                                                                                                                                                   *                          *   *                                                                                                                                                                       * @group row                                                                                                                                                            */                                                                                                                                                                     trait Row extends Serializable {