java - Comparación entre los diferentes métodos de ejecución de consultas SQL en Cassandra Column Families utilizando spark

apache-spark apache-spark-sql

Question

Como parte de mi proyecto, tengo que crear una interfaz de consulta SQL para un Dataset Cassandra muy grande, por lo tanto, he estado buscando diferentes métodos para ejecutar consultas SQL en familias de columnas de cassandra usando Spark y he encontrado tres métodos diferentes

1. utilizando Spark SQLContext con un esquema estáticamente definido

   // statically defined in the application
   public static class TableTuple implements Serializable {
   private int id;
   private String line;
   TableTuple (int i, String l) {
   id = i;
   line = l;
   }
   // getters and setters
   ...
   }

   y yo consumo la definición como:

   SparkConf conf = new SparkConf(true)
   .set("spark.cassandra.connection.host", CASSANDRA_HOST)
   .setJars(jars);
   SparkContext sc = new SparkContext(HOST, APP_NAME, conf);
   SQLContext sqlContext = new SQLContext(sc);
   JavaRDD<CassandraRow> rowrdd = javaFunctions(sc).cassandraTable(CASSANDRA_KEYSPACE, CASSANDRA_COLUMN_FAMILY);
   JavaRDD<TableTuple> rdd = rowrdd.map(row -> new TableTuple(row.getInt(0), row.getString(1)));
   DataFrame dataFrame = sqlContext.createDataFrame(rdd, TableTuple.class);
   dataFrame.registerTempTable("lines");
   DataFrame resultsFrame = sqlContext.sql("Select line from lines where id=1");
   System.out.println(Arrays.asList(resultsFrame.collect()));

2. utilizando Spark SQLContext con un esquema definido dinámicamente

   SparkConf conf = new SparkConf(true)
   .set("spark.cassandra.connection.host", CASSANDRA_HOST)
   .setJars(jars);
   SparkContext sc = new SparkContext(HOST, APP_NAME, conf);
   SQLContext sqlContext = new SQLContext(sc);
   JavaRDD<CassandraRow> cassandraRdd = javaFunctions(sc).cassandraTable(CASSANDRA_KEYSPACE, CASSANDRA_COLUMN_FAMILY);
   JavaRDD<Row> rdd = cassandraRdd.map(row -> RowFactory.create(row.getInt(0), row.getString(1)));
   List<StructField> fields = new ArrayList<>();
   fields.add(DataTypes.createStructField("id", DataTypes.IntegerType, true));
   fields.add(DataTypes.createStructField("line", DataTypes.StringType, true));
   StructType schema = DataTypes.createStructType(fields);
   DataFrame dataFrame = sqlContext.createDataFrame(rdd, schema);
   dataFrame.registerTempTable("lines");
   DataFrame resultDataFrame = sqlContext.sql("select line from lines where id = 1");
   System.out.println(Arrays.asList(resultDataFrame.collect()));

3. usando CassandraSQLContext desde el conector spark-cassandra

   SparkConf conf = new SparkConf(true)
   .set("spark.cassandra.connection.host", CASSANDRA_HOST)
   .setJars(jars);
   SparkContext sc = new SparkContext(HOST, APP_NAME, conf);
   CassandraSQLContext sqlContext = new CassandraSQLContext(sc);
   DataFrame resultsFrame = sqlContext.sql("Select line from " + CASSANDRA_KEYSPACE + "." + CASSANDRA_COLUMN_FAMILY + " where id = 1");
   System.out.println(Arrays.asList(resultsFrame.collect()));

Me gustaría saber las ventajas / desventajas de un método sobre otro. Además, para el método CassandraSQLContext , las consultas están limitadas a CQL, o es totalmente compatible con Spark SQL. También me gustaría un análisis relacionado con mi caso de uso específico, tengo una familia de columnas de cassandra con ~ 17.6 millones de tuplas que tienen 62 columnas. Para consultar una base de datos tan grande, ¿qué método es el más adecuado?