com.datastax.oss.driver.api.core.ConsistencyLevel Java Examples

@Test
public void should_generate_simple_statement() throws Exception {
  //Given
  String input = "SELECT * FROM users LIMIT 10;";
  CassandraQueryOptions options = new CassandraQueryOptions(Option.apply(QUORUM),
          Option.<ConsistencyLevel>empty(),
          Option.empty(),
          Option.empty(),
          Option.empty());

  //When
  final SimpleStatement actual = helper.generateSimpleStatement(new SimpleStm(input), options,
          intrContext);

  //Then
  assertThat(actual).isNotNull();
  assertThat(actual.getQuery()).isEqualTo("SELECT * FROM users LIMIT 10;");
  assertThat(actual.getConsistencyLevel()).isSameAs(QUORUM);
}
 

/**
 * Query Consistency Level as Object
 * @return object of consistencyLevel
 */
public ConsistencyLevel getConsistencyLevel() {
    if(this.consistency!=null) {
        return DefaultConsistencyLevel.valueOf(this.consistency);
    }
    return null;
}
 

@Test
public void should_generate_batch_statement() throws Exception {
  //Given
  SimpleStatement st1 = SimpleStatement.newInstance("SELECT * FROM users LIMIT 10;");
  SimpleStatement st2 = SimpleStatement.newInstance("INSERT INTO users(id) VALUES(10);");
  SimpleStatement st3 = SimpleStatement.newInstance(
          "UPDATE users SET name = 'John DOE' WHERE id=10;");
  CassandraQueryOptions options = new CassandraQueryOptions(Option.apply(QUORUM),
          Option.<ConsistencyLevel>empty(),
          Option.empty(),
          Option.empty(),
          Option.empty());

  //When
  BatchStatement actual = helper.generateBatchStatement(UNLOGGED, options,
          toScalaList(asList(st1, st2, st3)));

  //Then
  assertThat(actual).isNotNull();
  List<BatchableStatement> statements = new ArrayList<BatchableStatement>();
  for (BatchableStatement b: actual) {
    statements.add(b);
  }
  assertThat(statements).hasSize(3);
  assertThat(statements.get(0)).isSameAs(st1);
  assertThat(statements.get(1)).isSameAs(st2);
  assertThat(statements.get(2)).isSameAs(st3);
  assertThat(actual.getConsistencyLevel()).isSameAs(QUORUM);
}
 

@PostConstruct
public void initialize() {
    String cassandraHosts = env.getProperty("ea.cassandra.hosts","localhost:9042");
    String cassandraKeyspaceName = env.getProperty("ea.cassandra.keyspace","\"ElasticActors\"");
    Integer cassandraPort = env.getProperty("ea.cassandra.port", Integer.class, 9042);

    Set<String> hostSet = StringUtils.commaDelimitedListToSet(cassandraHosts);

    String[] contactPoints = new String[hostSet.size()];
    int i=0;
    for (String host : hostSet) {
        if(host.contains(":")) {
            contactPoints[i] = host.substring(0,host.indexOf(":"));
        } else {
            contactPoints[i] = host;
        }
        i+=1;
    }

    List<InetSocketAddress> contactPointAddresses = Arrays.stream(contactPoints)
            .map(host -> new InetSocketAddress(host, cassandraPort))
            .collect(Collectors.toList());

    DriverConfigLoader driverConfigLoader = DriverConfigLoader.programmaticBuilder()
            .withDuration(DefaultDriverOption.HEARTBEAT_INTERVAL, Duration.ofSeconds(60))
            .withString(DefaultDriverOption.REQUEST_CONSISTENCY, ConsistencyLevel.QUORUM.name())
            .withString(DefaultDriverOption.RETRY_POLICY_CLASS, "DefaultRetryPolicy")
            .withString(DefaultDriverOption.RECONNECTION_POLICY_CLASS, "ConstantReconnectionPolicy")
            .withDuration(DefaultDriverOption.RECONNECTION_BASE_DELAY, Duration.ofSeconds(env.getProperty("ea.cassandra.retryDownedHostsDelayInSeconds",Integer.class,1)))
            .withString(DefaultDriverOption.LOAD_BALANCING_POLICY_CLASS, "DcInferringLoadBalancingPolicy")
            .build();


    cassandraSession = CqlSession.builder()
            .addContactPoints(contactPointAddresses)
            .withConfigLoader(driverConfigLoader)
            .withKeyspace(cassandraKeyspaceName)
            .build();
}
 

public CassandraTransactionManager(CqlSession cqlSession, ConsistencyLevel consistencyLevel) {
    this.cqlSession = cqlSession;
    this.consistencyLevel = consistencyLevel;
}
 

@Before
public void testBefore() {
    manager = new CassandraTransactionManager(cqlSession, ConsistencyLevel.QUORUM);
    manager.create(name);
}
 

ConsistencyLevel getReadConsistencyLevel() {
    return this.readConsistencyLevel;
}
 

ConsistencyLevel getWriteConsistencyLevel() {
    return this.writeConsistencyLevel;
}
 

CassandraStorageAccessor(@NonNull CqlSession cqlSession, @NonNull String table, @NonNull ConsistencyLevel consistencyLevel) {
    this.hostname = Utils.getHostname();
    this.table = table;
    this.cqlSession = cqlSession;
    this.consistencyLevel = consistencyLevel;
}
 

public CassandraLockProvider(@NonNull CqlSession cqlSession) {
    super(new CassandraStorageAccessor(cqlSession, DEFAULT_TABLE, ConsistencyLevel.QUORUM));
}
 

public CassandraLockProvider(@NonNull CqlSession cqlSession, @NonNull String table, @NonNull ConsistencyLevel consistencyLevel) {
    super(new CassandraStorageAccessor(cqlSession, table, consistencyLevel));
}
 

private Lock findLock(String lockName) {
    CassandraStorageAccessor cassandraStorageAccessor = new CassandraStorageAccessor(cqlSession, CassandraLockProvider.DEFAULT_TABLE, ConsistencyLevel.QUORUM);
    return cassandraStorageAccessor.find(lockName).get();
}