@Test public void should_initialize_lazy_properties() throws Exception { Tweet tweet = new Tweet(); tweet.setId(UUIDGen.getTimeUUID()); tweet.setContent("welcome"); CompleteBean entity = CompleteBeanTestBuilder.builder() .randomId() .name("name") .label("label") .age(45L) .addFriends("foo", "bar") .welcomeTweet(tweet) .version(CounterBuilder.incr(11L)) .buid(); manager.insert(entity); CompleteBean foundEntity = manager.find(CompleteBean.class, entity.getId()); CompleteBean rawEntity = manager.initAndRemoveProxy(foundEntity); assertThat(rawEntity.getName()).isEqualTo("name"); assertThat(rawEntity.getLabel()).isEqualTo("label"); assertThat(rawEntity.getAge()).isEqualTo(45L); assertThat(rawEntity.getFriends()).containsExactly("foo", "bar"); assertThat(rawEntity.getWelcomeTweet().getContent()).isEqualTo("welcome"); assertThat(rawEntity.getVersion()).isInstanceOf(InternalCounterImpl.class); assertThat(rawEntity.getVersion().get()).isEqualTo(11L); }
@Test public void should_query_with_default_params() throws Exception { long partitionKey = RandomUtils.nextLong(); List<ClusteredEntityWithReverseClustering> entities = manager .sliceQuery(ClusteredEntityWithReverseClustering.class) .partitionComponents(partitionKey) .getFirst(5); assertThat(entities).isEmpty(); insertValues(partitionKey, 5); entities = manager .sliceQuery(ClusteredEntityWithReverseClustering.class) .partitionComponents(partitionKey) .fromClusterings(4) .toClusterings(2) .get(); assertThat(entities).hasSize(3); assertThat(entities.get(0).getValue()).isEqualTo("value4"); assertThat(entities.get(0).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(0).getId().getCount()).isEqualTo(4); assertThat(entities.get(0).getId().getName()).isEqualTo("name4"); assertThat(entities.get(1).getValue()).isEqualTo("value3"); assertThat(entities.get(1).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(1).getId().getCount()).isEqualTo(3); assertThat(entities.get(1).getId().getName()).isEqualTo("name3"); assertThat(entities.get(2).getValue()).isEqualTo("value2"); assertThat(entities.get(2).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(2).getId().getCount()).isEqualTo(2); assertThat(entities.get(2).getId().getName()).isEqualTo("name2"); entities = manager .sliceQuery(ClusteredEntityWithReverseClustering.class) .fromEmbeddedId(new ClusteredKey(partitionKey, 4, null)) .toEmbeddedId(new ClusteredKey(partitionKey, 2, null)) .get(); assertThat(entities).hasSize(3); assertThat(entities.get(0).getValue()).isEqualTo("value4"); assertThat(entities.get(0).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(0).getId().getCount()).isEqualTo(4); assertThat(entities.get(0).getId().getName()).isEqualTo("name4"); assertThat(entities.get(1).getValue()).isEqualTo("value3"); assertThat(entities.get(1).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(1).getId().getCount()).isEqualTo(3); assertThat(entities.get(1).getId().getName()).isEqualTo("name3"); assertThat(entities.get(2).getValue()).isEqualTo("value2"); assertThat(entities.get(2).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(2).getId().getCount()).isEqualTo(2); assertThat(entities.get(2).getId().getName()).isEqualTo("name2"); }
@Test public void should_query_with_reverse_ordering() throws Exception { long partitionKey = RandomUtils.nextLong(); insertValues(partitionKey, 5); List<ClusteredEntityWithReverseClustering> entities = manager .sliceQuery(ClusteredEntityWithReverseClustering.class) .partitionComponents(partitionKey) .fromClusterings(2) .toClusterings(4) .ordering(DESCENDING) .get(); assertThat(entities).hasSize(3); assertThat(entities.get(0).getValue()).isEqualTo("value2"); assertThat(entities.get(0).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(0).getId().getCount()).isEqualTo(2); assertThat(entities.get(0).getId().getName()).isEqualTo("name2"); assertThat(entities.get(1).getValue()).isEqualTo("value3"); assertThat(entities.get(1).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(1).getId().getCount()).isEqualTo(3); assertThat(entities.get(1).getId().getName()).isEqualTo("name3"); assertThat(entities.get(2).getValue()).isEqualTo("value4"); assertThat(entities.get(2).getId().getId()).isEqualTo(partitionKey); assertThat(entities.get(2).getId().getCount()).isEqualTo(4); assertThat(entities.get(2).getId().getName()).isEqualTo("name4"); }
private void insertClusteredEntity( Long partitionKey, int count, String name, String clusteredValue) { ClusteredKey embeddedId = new ClusteredKey(partitionKey, count, name); ClusteredEntityWithReverseClustering entity = new ClusteredEntityWithReverseClustering(embeddedId, clusteredValue); manager.persist(entity); }
private void insertClusteredEntity( Long partitionKey, int count, String name, String clusteredValue) { ClusteredEntity.CompoundPK compoundPK = new ClusteredEntity.CompoundPK(partitionKey, count, name); ClusteredEntity entity = new ClusteredEntity(compoundPK, clusteredValue); manager.insert(entity); }
@Test public void should_iterate_with_partition_keys_and_partition_keys_IN_and_from_clusterings() throws Exception { // Given long partitionKey = RandomUtils.nextLong(0, Long.MAX_VALUE); insertCompositeClusteredValues(partitionKey, "bucket1", 1, "abc", 1); insertCompositeClusteredValues(partitionKey, "bucket2", 1, "name", 1); insertCompositeClusteredValues(partitionKey, "bucket3", 1, "name", 1); // When final Iterator<CompositeClusteredEntity> iterator = manager .sliceQuery(CompositeClusteredEntity.class) .forIteration() .withPartitionComponents(partitionKey) .andPartitionComponentsIN("bucket1", "bucket3") .fromClusterings(1, "name1") .iterator(); // Then assertThat(iterator.hasNext()).isTrue(); CompositeClusteredEntity next = iterator.next(); assertThat(next.getId().getBucket()).isEqualTo("bucket3"); assertThat(next.getId().getName()).isEqualTo("name1"); assertThat(next.getValue()).isEqualTo("value11"); }
@Test public void should_iterate_with_custom_params() throws Exception { long partitionKey = RandomUtils.nextLong(0, Long.MAX_VALUE); insertClusteredValues(partitionKey, 1, "name1", 5); insertClusteredValues(partitionKey, 1, "name2", 5); Iterator<ClusteredEntity> iter = manager .sliceQuery(ClusteredEntity.class) .forIteration() .withPartitionComponents(partitionKey) .fromClusterings(1, "name13") .toClusterings(1, "name21") .iterator(2); assertThat(iter.hasNext()).isTrue(); assertThat(iter.next().getValue()).isEqualTo("value13"); assertThat(iter.hasNext()).isTrue(); assertThat(iter.next().getValue()).isEqualTo("value14"); assertThat(iter.hasNext()).isTrue(); assertThat(iter.next().getValue()).isEqualTo("value15"); assertThat(iter.hasNext()).isTrue(); final ClusteredEntity next = iter.next(); assertThat(next.getId().getName()).isEqualTo("name21"); assertThat(next.getValue()).isEqualTo("value11"); assertThat(iter.hasNext()).isFalse(); }
@Test public void should_check_for_common_operation_on_found_clustered_entity_by_iterator() throws Exception { long partitionKey = RandomUtils.nextLong(0, Long.MAX_VALUE); insertClusteredValues(partitionKey, 1, "name1", 1); Iterator<ClusteredEntity> iter = manager .sliceQuery(ClusteredEntity.class) .forIteration() .withPartitionComponents(partitionKey) .iterator(); iter.hasNext(); ClusteredEntity clusteredEntity = iter.next(); // Check for update clusteredEntity.setValue("dirty"); manager.update(clusteredEntity); ClusteredEntity check = manager.find(ClusteredEntity.class, clusteredEntity.getId()); assertThat(check.getValue()).isEqualTo("dirty"); // Check for refresh check.setValue("dirty_again"); manager.update(check); manager.refresh(clusteredEntity); assertThat(clusteredEntity.getValue()).isEqualTo("dirty_again"); // Check for remove manager.delete(clusteredEntity); assertThat(manager.find(ClusteredEntity.class, clusteredEntity.getId())).isNull(); }
@Test public void should_initialize_counter_value() throws Exception { CompleteBean entity = CompleteBeanTestBuilder.builder().randomId().name("name").buid(); entity = manager.insert(entity); entity.getVersion().incr(2L); manager.update(entity); RegularStatement statement = select().from("CompleteBean").where(eq("id", bindMarker())); CompleteBean foundEntity = manager.typedQuery(CompleteBean.class, statement, entity.getId()).getFirst(); CompleteBean rawEntity = manager.initAndRemoveProxy(foundEntity); assertThat(rawEntity.getVersion()).isInstanceOf(InternalCounterImpl.class); assertThat(rawEntity.getVersion().get()).isEqualTo(2L); }
@Test public void should_re_prepare_statements_when_cache_size_exceeded() throws Exception { // Given CompleteBean bean = builder().id(RandomUtils.nextLong(0, Long.MAX_VALUE)).name("name").buid(); CompleteBean managed = pm.insert(bean); // When managed.setAge(10L); pm.update(managed); managed.setFriends(Arrays.asList("foo", "bar")); pm.update(managed); managed.setFollowers(Sets.newHashSet("George", "Paul")); pm.update(managed); managed.setAge(11L); pm.update(managed); // Then CompleteBean found = pm.find(CompleteBean.class, bean.getId()); assertThat(found.getAge()).isEqualTo(11L); assertThat(found.getName()).isEqualTo("name"); assertThat(found.getFriends()).containsExactly("foo", "bar"); assertThat(found.getFollowers()).containsOnly("George", "Paul"); }
@Bean(destroyMethod = "shutDown") public PersistenceManager getPersistenceManager() { final List<String> activeProfiles = Arrays.asList(env.getActiveProfiles()); boolean isProduction = activeProfiles.contains(Profiles.SPRING_PROFILE_PRODUCTION); PersistenceManagerFactory pmFactory = PersistenceManagerFactoryBuilder.builder(cluster) .withEntityPackages(UserEntity.class.getPackage().getName()) .withDefaultReadConsistency(ConsistencyLevel.ONE) .withDefaultWriteConsistency(ConsistencyLevel.ONE) .withKeyspaceName(Schema.KEYSPACE) .withExecutorServiceMinThreadCount(5) .withExecutorServiceMaxThreadCount(10) .forceTableCreation(isProduction ? false : true) .build(); final PersistenceManager pm = pmFactory.createPersistenceManager(); pm.insert( UserEntity.fromModel(KILLRCHAT_USER), OptionsBuilder.ifNotExists() .lwtResultListener( new LWTResultListener() { @Override public void onSuccess() { logger.info("Create new administration 'killrchat' account"); } @Override public void onError(LWTResult lwtResult) { logger.debug("Administration 'killrchat' account already exists"); } })); return pm; }
@Test public void should_iterate_with_clustering_IN() throws Exception { // Given long partitionKey = RandomUtils.nextLong(0, Long.MAX_VALUE); insertClusteredValues(partitionKey, 1, "name1", 3); insertClusteredValues(partitionKey, 1, "name2", 2); insertClusteredValues(partitionKey, 1, "name3", 1); insertClusteredValues(partitionKey, 1, "name4", 1); // When final Iterator<ClusteredEntity> iterator = manager .sliceQuery(ClusteredEntity.class) .forIteration() .withPartitionComponents(partitionKey) .withClusterings(1) .andClusteringsIN("name11", "name12", "name13", "name41") .limit(100) .iterator(2); // Then assertThat(iterator.hasNext()).isTrue(); ClusteredEntity next = iterator.next(); assertThat(next.getId().getName()).isEqualTo("name11"); assertThat(next.getValue()).isEqualTo("value11"); assertThat(iterator.hasNext()).isTrue(); next = iterator.next(); assertThat(next.getId().getName()).isEqualTo("name12"); assertThat(next.getValue()).isEqualTo("value12"); assertThat(iterator.hasNext()).isTrue(); next = iterator.next(); assertThat(next.getId().getName()).isEqualTo("name13"); assertThat(next.getValue()).isEqualTo("value13"); assertThat(iterator.hasNext()).isTrue(); next = iterator.next(); assertThat(next.getId().getName()).isEqualTo("name41"); assertThat(next.getValue()).isEqualTo("value11"); assertThat(iterator.hasNext()).isFalse(); }
@Test public void should_iterate_over_clusterings_components() throws Exception { // Given long partitionKey = RandomUtils.nextLong(0, Long.MAX_VALUE); insertClusteredValues(partitionKey, 1, "name1", 3); insertClusteredValues(partitionKey, 2, "name2", 2); insertClusteredValues(partitionKey, 3, "name3", 1); insertClusteredValues(partitionKey, 4, "name4", 1); // When final Iterator<ClusteredEntity> iterator = manager .sliceQuery(ClusteredEntity.class) .forIteration() .withPartitionComponents(partitionKey) .fromClusterings(1) .fromInclusiveToExclusiveBounds() .limit(6) .iterator(2); // Then assertThat(iterator.hasNext()).isTrue(); assertThat(iterator.next().getValue()).isEqualTo("value11"); assertThat(iterator.hasNext()).isTrue(); assertThat(iterator.next().getValue()).isEqualTo("value12"); assertThat(iterator.hasNext()).isTrue(); assertThat(iterator.next().getValue()).isEqualTo("value13"); assertThat(iterator.hasNext()).isTrue(); assertThat(iterator.next().getValue()).isEqualTo("value21"); assertThat(iterator.hasNext()).isTrue(); assertThat(iterator.next().getValue()).isEqualTo("value22"); assertThat(iterator.hasNext()).isTrue(); assertThat(iterator.next().getValue()).isEqualTo("value31"); assertThat(iterator.hasNext()).isFalse(); }
private void insertCompositeClusteredEntity( long id, String bucket, int count, String name, String clusteredValue) { CompoundPK compoundPK = new CompoundPK(id, bucket, count, name); CompositeClusteredEntity entity = new CompositeClusteredEntity(compoundPK, clusteredValue); manager.insert(entity); }