Package org.opennms.features.distributed.kvstore.pgshared

Class AbstractPostgresKeyValueStore<T,​S>

  • Type Parameters:
    T - the type this store persists
    S - the SQL type this store persists if the value type must be wrapped with an SQL type
    All Implemented Interfaces:
    KeyValueStore<T>
    Direct Known Subclasses:
    PostgresBlobStore, PostgresJsonStore
    public abstract class AbstractPostgresKeyValueStore<T,​S>
extends AbstractAsyncKeyValueStore<T>
    A KeyValueStore backed by Postgres.

    Postgres key value stores should implement this class with concrete types.

    • Constructor Detail

      • AbstractPostgresKeyValueStore

        public AbstractPostgresKeyValueStore​(DataSource dataSource)

    • Method Detail

      • put

        public long put​(String key,
                T value,
                String context,
                Integer ttlInSeconds)
        Description copied from interface: KeyValueStore
        Put a value with a suggested time-to-live after which the value should be expired and removed from the store.

        Records are expired on a best effort basis and depending on the implementation it is possible to get an expired record.

        context - a context used to differentiate between keys with the same name (forms a compound key)
        ttlInSeconds - the time to live in seconds for this key or no ttl if null
        Returns:
        the timestamp the value was persisted with

      • get

        public Optional<T> get​(String key,
                       String context)
        context - a context used to differentiate between keys with the same name (forms a compound key)
        Returns:
        an optional containing the value if present or empty if the key did not exist

      • getIfStale

        public Optional<Optional<T>> getIfStale​(String key,
                                        String context,
                                        long timestamp)
        context - a context used to differentiate between keys with the same name (forms a compound key)
        timestamp - the timestamp of the last known state such that if an record with a more recent timestamp is found the provided timestamp will be considered stale and the new record will be returned
        Returns:
        an optional that will be empty if the key was not found or will contain another optional that will be empty if not stale or contain the value if stale

      • getLastUpdated

        public OptionalLong getLastUpdated​(String key,
                                   String context)
        context - a context used to differentiate between keys with the same name (forms a compound key)
        Returns:
        an optional containing the timestamp the key's value was last updated or empty if the key did not exist

      • enumerateContext

        public Map<String,​T> enumerateContext​(String context)
        Parameters:
        context - a context used to differentiate between keys with the same name (forms a compound key)
        Returns:
        a map of all the records matching the given context where the map's key is the record's key and the map's value is the records value

      • delete

        public void delete​(String key,
                   String context)
        context - a context used to differentiate between keys with the same name (forms a compound key)

      • getSQLTypeFromValueType

        protected S getSQLTypeFromValueType​(T value)
        Sub classes should override this method to provide handling for converting from type T to a JDBC type if type T is not a native JDBC type.

      • getValueTypeFromSQLType

        protected abstract T getValueTypeFromSQLType​(ResultSet resultSet,
                                             String columnName)
                                      throws SQLException
        Sub classes must override this method to provide handling for converting from the JDBC result to type T.
        Throws:
        SQLException

      • getValueStatementPlaceholder

        protected String getValueStatementPlaceholder()
        Sub classes should override this to add additional specificity to the SQL placeholder in the prepared statements if necessary.

      • getTableName

        protected abstract String getTableName()
        Returns:
        the name of the table for this store

      • getPkConstraintName

        protected abstract String getPkConstraintName()
        Returns:
        the name of the primary key constraint for the table this store persists to

      • getName

        public String getName()
        Returns:
        the name of the backing implementation