Examples with RLexSortedSetAsync org.redisson.api.RLexSortedSetAsync used on opensource projects

Example 1 with RLexSortedSetAsync

use of org.redisson.api.RLexSortedSetAsync in project gora by apache.

the class RedisStore method put.

@Override
public void put(K key, T obj) throws GoraException {
    try {
        if (obj.isDirty()) {
            Schema objectSchema = obj.getSchema();
            List<Schema.Field> fields = objectSchema.getFields();
            RBatch batchInstance = redisInstance.createBatch();
            // update secundary index
            if (isNumericKey()) {
                RScoredSortedSetAsync<Object> secundaryIndex = batchInstance.getScoredSortedSet(generateIndexKey());
                secundaryIndex.addAsync(obtainDoubleValue(key), key);
            } else {
                RLexSortedSetAsync secundaryIndex = batchInstance.getLexSortedSet(generateIndexKey());
                secundaryIndex.addAsync(key.toString());
            }
            if (mode == StorageMode.SINGLEKEY) {
                RMapAsync<Object, Object> map = batchInstance.getMap(generateKeyHash(key));
                fields.forEach((field) -> {
                    Object fieldValue = handler.serializeFieldValue(field.schema(), obj.get(field.pos()));
                    if (fieldValue != null) {
                        map.fastPutAsync(mapping.getFields().get(field.name()), fieldValue);
                    } else {
                        map.fastRemoveAsync(mapping.getFields().get(field.name()));
                    }
                });
            } else {
                for (Schema.Field field : fields) {
                    Object fieldValue = obj.get(field.pos());
                    String redisField = mapping.getFields().get(field.name());
                    RedisType redisType = mapping.getTypes().get(field.name());
                    switch(redisType) {
                        case STRING:
                            RBucketAsync<Object> bucket = batchInstance.getBucket(generateKeyString(redisField, key));
                            bucket.deleteAsync();
                            if (fieldValue != null) {
                                fieldValue = handler.serializeFieldValue(field.schema(), fieldValue);
                                bucket.setAsync(fieldValue);
                            }
                            break;
                        case LIST:
                            RListAsync<Object> rlist = batchInstance.getList(generateKeyString(redisField, key));
                            rlist.deleteAsync();
                            if (fieldValue != null) {
                                List<Object> list = handler.serializeFieldList(field.schema(), fieldValue);
                                rlist.addAllAsync(list);
                            }
                            break;
                        case HASH:
                            RMapAsync<Object, Object> map = batchInstance.getMap(generateKeyString(redisField, key));
                            map.deleteAsync();
                            if (fieldValue != null) {
                                Map<Object, Object> mp = handler.serializeFieldMap(field.schema(), fieldValue);
                                map.putAllAsync(mp);
                            }
                            break;
                        default:
                            throw new AssertionError(redisType.name());
                    }
                }
            }
            batchInstance.execute();
        } else {
            LOG.info("Ignored putting object {} in the store as it is neither " + "new, neither dirty.", new Object[] { obj });
        }
    } catch (Exception e) {
        throw new GoraException(e);
    }
}

Example 2 with RLexSortedSetAsync

use of org.redisson.api.RLexSortedSetAsync in project gora by apache.

the class RedisStore method delete.

@Override
public boolean delete(K key) throws GoraException {
    try {
        RBatch batchInstance = redisInstance.createBatch();
        // update secundary index
        if (isNumericKey()) {
            RScoredSortedSetAsync<Object> secundaryIndex = batchInstance.getScoredSortedSet(generateIndexKey());
            secundaryIndex.removeAsync(key);
        } else {
            RLexSortedSetAsync secundaryIndex = batchInstance.getLexSortedSet(generateIndexKey());
            secundaryIndex.removeAsync(key.toString());
        }
        if (mode == StorageMode.SINGLEKEY) {
            RMapAsync<Object, Object> map = batchInstance.getMap(generateKeyHash(key));
            RFuture<Boolean> deleteAsync = map.deleteAsync();
            batchInstance.execute();
            return deleteAsync.get();
        } else {
            batchInstance.execute();
            return redisInstance.getKeys().deleteByPattern(generateKeyStringBase(key) + WILDCARD) > 0;
        }
    } catch (Exception ex) {
        throw new GoraException(ex);
    }
}

Example 3 with RLexSortedSetAsync

use of org.redisson.api.RLexSortedSetAsync in project gora by apache.

the class RedisStore method deleteByQuery.

@Override
public long deleteByQuery(Query<K, T> query) throws GoraException {
    Collection<K> range = runQuery(query);
    RBatch batchInstance = redisInstance.createBatch();
    RLexSortedSetAsync secundaryIndex = batchInstance.getLexSortedSet(generateIndexKey());
    if (query.getFields() != null && query.getFields().length < mapping.getFields().size()) {
        List<String> dbFields = new ArrayList<>();
        List<RedisType> dbTypes = new ArrayList<>();
        for (String af : query.getFields()) {
            dbFields.add(mapping.getFields().get(af));
            dbTypes.add(mapping.getTypes().get(af));
        }
        for (K key : range) {
            if (mode == StorageMode.SINGLEKEY) {
                RMapAsync<Object, Object> map = batchInstance.getMap(generateKeyHash(key));
                dbFields.forEach((field) -> {
                    map.removeAsync(field);
                });
            } else {
                for (int indexField = 0; indexField < dbFields.size(); indexField++) {
                    String field = dbFields.get(indexField);
                    RedisType type = dbTypes.get(indexField);
                    switch(type) {
                        case STRING:
                            RBucketAsync<Object> bucket = batchInstance.getBucket(generateKeyString(field, key));
                            bucket.deleteAsync();
                            break;
                        case LIST:
                            RListAsync<Object> rlist = batchInstance.getList(generateKeyString(field, key));
                            rlist.deleteAsync();
                            break;
                        case HASH:
                            RMapAsync<Object, Object> map = batchInstance.getMap(generateKeyString(field, key));
                            map.deleteAsync();
                            break;
                        default:
                            throw new AssertionError(type.name());
                    }
                }
            }
        }
    } else {
        range.stream().map((key) -> {
            secundaryIndex.removeAsync(key);
            return key;
        }).forEachOrdered((key) -> {
            if (mode == StorageMode.SINGLEKEY) {
                RMapAsync<Object, Object> map = batchInstance.getMap(generateKeyHash(key));
                map.deleteAsync();
            } else {
                redisInstance.getKeys().deleteByPattern(generateKeyStringBase(key) + WILDCARD);
            }
        });
    }
    batchInstance.execute();
    return range.size();
}