Converts RowColumnValue RDD to RowColumn/Bytes PairRDD

@param rcvRDD RowColumnValue RDD to convert
@return RowColumn/Bytes PairRDD
172948
public static JavaPairRDD<RowColumn, Bytes> toPairRDD(JavaRDD<RowColumnValue> rcvRDD) {
    return rcvRDD.mapToPair(rcv -> new Tuple2<>(rcv.getRowColumn(), rcv.getValue()));
  }
874349
def rowIdColumns(self, table, catalog=None, schema=None,  # nopep8
                     nullable=True):
        
        fut = self._run_operation(self._impl.rowIdColumns, table,
                                  catalog=catalog, schema=schema,
                                  nullable=nullable)
        return fut
692281
@Override
  public final ColumnsValues convert(final Map<String, Object> pAddParam,
    final T pObject) throws Exception {
    ColumnsValues result = this.cnvObjectToColumnsValues
      .convert(pAddParam, pObject);
    if (pAddParam.get("isOnlyId") == null) {
      pObject.setItsVersion(result.getLong(ISrvOrm.VERSION_NAME));
    }
    return result;
  }
771897
public RowVector getRow(int r) throws MatrixException
    {
        if ((r < 0) || (r >= nRows)) {
            throw new MatrixException(MatrixException.INVALID_INDEX);
        }

        RowVector rv = new RowVector(nCols);
        for (int c = 0; c < nCols; ++c) {
            rv.values[0][c] = this.values[r][c];
        }

        return rv;
    }
691486
public final FctBnCnvIbnToColumnValues
    lazyGetFctBnCnvIbnToColumnValues() throws Exception {
    String beanName = getFctBnCnvIbnToColumnValuesName();
    FctBnCnvIbnToColumnValues fctBnCnvIbnToColumnValues =
      (FctBnCnvIbnToColumnValues) this.beansMap.get(beanName);
    if (fctBnCnvIbnToColumnValues == null) {
      fctBnCnvIbnToColumnValues = new FctBnCnvIbnToColumnValues();
      fctBnCnvIbnToColumnValues.setUtlReflection(lazyGetUtlReflection());
      fctBnCnvIbnToColumnValues.setFieldsRapiHolder(lazyGetHolderRapiFields());
      fctBnCnvIbnToColumnValues
        .setGettersRapiHolder(lazyGetHolderRapiGetters());
      fctBnCnvIbnToColumnValues.setIsNeedsToSqlEscape(getIsNeedsToSqlEscape());
      fctBnCnvIbnToColumnValues.setSrvSqlEscape(lazyGetSrvSqlEscape());
      this.beansMap.put(beanName, fctBnCnvIbnToColumnValues);
      lazyGetLogger().info(null, AFactoryAppBeans.class, beanName
        + " has been created.");
    }
    return fctBnCnvIbnToColumnValues;
  }
309849
public DataFrame createJavaSchemaRDD(ExtractorConfig<Cells> config) throws UnsupportedDataTypeException, UnsupportedOperationException {
        JavaRDD<Cells> cellsRDD = createJavaRDD(config);
        JavaRDD<Row> rowsRDD = DeepSparkContext.createJavaRowRDD(cellsRDD);
        try {
            Cells firstCells = cellsRDD.first();
            StructType schema = CellsUtils.getStructTypeFromCells(firstCells);
            return sqlContext.applySchema(rowsRDD, schema);
        } catch(UnsupportedOperationException e) {
            throw new UnsupportedOperationException("Cannot infer schema from empty data RDD", e);
        }
    }
1157697
def parse(readDataInstance):
        
        d = Directory()
        d.rva.value = readDataInstance.readDword()
        d.size.value = readDataInstance.readDword()
        return d
1335713
public static String rc2name( int row, int col ){
        StringBuilder sb = new StringBuilder();
        int b = 26;
        int p = 1;
        if( col >= b  ){
            col -= b;
            p *= b;
        }
        if( col >= b*b ){
            col -= b*b;
            p *= b;
        }
        while( p > 0 ){
            sb.append( (char)(col/p + (int)'A') );
            col %= p;
            p /= b;
        }
        sb.append( row + 1 );
        return sb.toString();
    }
672462
public static ColumnValue orr(String column, Serializable value) {
        return new ColumnValue(column, ORR, value);
    }
1117155
public static Pair<Schema, JavaRDD<List<Writable>>> toRecords(DataRowsFacade dataFrame) {
        Schema schema = fromStructType(dataFrame.get().schema());
        return new Pair<>(schema, dataFrame.get().javaRDD().map(new ToRecord(schema)));
    }
289329
@Override
  public final ColumnarArray getArray(int rowId) {
    if (isNullAt(rowId)) return null;
    return new ColumnarArray(arrayData(), getArrayOffset(rowId), getArrayLength(rowId));
  }
378762
@SuppressWarnings("unchecked")
    public CassandraJavaPairRDD<K, V> withConnector(CassandraConnector connector) {
        CassandraRDD<Tuple2<K, V>> newRDD = rdd().withConnector(connector);
        return wrap(newRDD);
    }
348681
private Object getValue(final ResultSet rs, final ResultSetMetaData rsmd, final int columnIndex)
			throws SQLException {
		JavaType javaType = this.dialect.getJavaType(rsmd.getColumnType(columnIndex),
				rsmd.getColumnTypeName(columnIndex));
		return this.mapperManager.getValue(javaType, rs, columnIndex);
	}
72112
private ByteBuffer columnValueAsBytes(ByteBuffer columnName, String columnFamilyName, String columnValue)
    {
        CfDef columnFamilyDef = getCfDef(columnFamilyName);
        AbstractType<?> defaultValidator = getFormatType(columnFamilyDef.default_validation_class);

        for (ColumnDef columnDefinition : columnFamilyDef.getColumn_metadata())
        {
            byte[] currentColumnName = columnDefinition.getName();

            if (ByteBufferUtil.compare(currentColumnName, columnName) == 0)
            {
                try
                {
                    String validationClass = columnDefinition.getValidation_class();
                    return getBytesAccordingToType(columnValue, getFormatType(validationClass));
                }
                catch (Exception e)
                {
                    throw new RuntimeException(e);
                }
            }
        }

        return defaultValidator.fromString(columnValue);
    }
902487
function convertRawDate(rawColumnValue, column, context)
{
  return new SfTimestamp(
      Number(rawColumnValue) * 86400, // convert to seconds
      0,                              // no nano seconds
      0,                              // no scale required
      'UTC',                          // use utc as the timezone
      context.format).toSfDate();
}
757207
@SuppressWarnings("unchecked")
    public CassandraJavaPairRDD<K, V> withReadConf(ReadConf config) {
        CassandraRDD<Tuple2<K, V>> newRDD = rdd().withReadConf(config);
        return wrap(newRDD);
    }
1319762
private Optional<Object> getWriterPartitionColumnValue(GenericRecord record) {
    if (!this.partitionColumns.isPresent()) {
      return Optional.absent();
    }

    for (String partitionColumn : this.partitionColumns.get()) {
      Optional<Object> fieldValue = AvroUtils.getFieldValue(record, partitionColumn);
      if (fieldValue.isPresent()) {
        return fieldValue;
      }
    }
    return Optional.absent();
  }