[
https://issues.apache.org/jira/browse/IGNITE-51?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Alexey Goncharuk updated IGNITE-51:
-----------------------------------
Description:
# Need to introduce interface {{CacheObject}} and {{KeyCacheObject}} that will
hide the implementation details of cached object representation.
{code}
public interface CacheObject {
public <T> T value(GridCacheContext ctx);
public <T> T getField(String name);
public byte[] valueBytes();
}
public interface KeyCacheObject extends CacheObject {
public int hashCode();
}
{code}
Implementation of this class must always store serialized form of the object
and should be optionally store deserialized form of the object. Cache object
must never keep the original reference of the user object.
# Inside {{GridCacheMapEntry}} fields {{key}}, {{keyBytes}}, {{value}} and
{{valueBytes}} should be replaced with corresponding {{CacheObject}} references.
# Same goes for other cache classes that were using keys, values or thereof
bytes implicitly ({{IgniteTxEntry}}, {{GridCacheEntryInfo}}, etc)
# Transformation of user object to a cache object in Ignite should be
implemented in {{GridPortableProcessor}} which should be renamed to
{{IgniteCacheObjectProcessor}}. {{IgniteCacheSerializarionManager}} should be
removed.
# Marshalling of {{CacheObject}} should take advantage of portable marshalling
mechanism and always use only the serialized bytes stored in the
{{CacheObject}}. In current implementation {{CacheObjectImpl}} should extend
{{MessageAdapter}} (UPDATE WILL FOLLOW).
# {{storeValueBytes}} flag should be removed from configuration.
# Internal cache API should use {{CacheObject}} exclusively and wrap/unwrap it
to/from user objects on the very top-level-proxy level (unwrap is for sure,
wrap is subject to discuss).
# {{cacheKeyBinaryEquality}} flag should be introduced to cache configuration
(default true). When true, cache keys should not be deserialized and binary
form of the object altogether with the hash code should be used to check key
equality. {{GridCacheConcurrentMap}} should be updated accordingly.
# {{copyOnGet}} flag should be added to cache configuration (default true).
When true, new value should be deserialized and returned to user on each cache
operation implying return value. Ignite should maintain a list of known
immutable types (such as {{Integer}}, {{String}}) for which {{copyOnGet}} is
ignored. New annotation {{@IgniteImmutable}} should be introduced to mark
immutable types for which this flag is also ignored.
# When indexing is enabled, {{CacheObject}} should always keep deserialized
version of user object. {{getField()}} method should be used in indexing to
obtain indexed fields via reflection. {{getField()}} should maintain necessary
reflection cache to keep current performance level. See {{IgniteH2Indexing}}
for details.
was:
# Need to introduce interface {{CacheObject}} and {{KeyCacheObject}} that will
hide the implementation details of cached object representation.
{code}
public interface CacheObject {
public <T> T value(GridCacheContext ctx);
public <T> T getField(String name);
public byte[] valueBytes();
}
public interface KeyCacheObject extends CacheObject {
public int hashCode();
}
{code}
Implementation of this class must always store serialized form of the object
and should be optionally store deserialized form of the object. Cache object
must never keep the original reference of the user object.
# Inside {{GridCacheMapEntry}} fields {{key}}, {{keyBytes}}, {{value}} and
{{valueBytes}} should be replaced with corresponding {{CacheObject}} references.
# Same goes for other cache classes that were using keys, values or thereof
bytes implicitly ({{IgniteTxEntry}}, {{GridCacheEntryInfo}}, etc)
# Transformation of user object to a cache object in Ignite should be
implemented in {{GridPortableProcessor}} which should be renamed to
{{IgniteCacheObjectProcessor}}. {{IgniteCacheSerializarionManager}} should be
removed.
# Marshalling of {{CacheObject}} should take advantage of portable marshalling
mechanism and always use only the serialized bytes stored in the
{{CacheObject}}. In current implementation {{CacheObjectImpl}} should extend
{{MessageAdapter}} (UPDATE WILL FOLLOW).
# {{storeValueBytes}} flag should be removed from configuration.
# Internal cache API should use {{CacheObject}} exclusively and wrap/unwrap it
to/from user objects on the very top-level-proxy level (unwrap is for sure,
wrap is subject to discuss).
# {{cacheKeyBinaryEquality}} flag should be introduced to cache configuration
(default true). When true, cache keys should not be deserialized and binary
form of the object altogether with the hash code should be used to check key
equality. {{GridCacheConcurrentMap}} should be updated accordingly.
# {{copyOnGet}} flag should be added to cache configuration (default true).
When true, new value should be deserialized and returned to user on each cache
operation implying return value. Ignite should maintain a list of known
immutable types (such as {{Integer}}, {{String}}) for which {{copyOnGet}} is
ignored. New annotation {{@IgniteImmutable}} should be introduced to mark
immutable types for which this flag is also ignored.
# When indexing is enabled, CacheObject should always keep deserialized version
of user object. {{getField()}} method should be used in indexing to obtain
indexed fields via reflection. {{getField()}} should maintain necessary
reflection cache to keep current performance level. See {{IgniteH2Indexing}}
for details.
> Support store-by-value mode
> ---------------------------
>
> Key: IGNITE-51
> URL: https://issues.apache.org/jira/browse/IGNITE-51
> Project: Ignite
> Issue Type: Sub-task
> Components: cache
> Reporter: Semen Boikov
> Assignee: Alexey Goncharuk
> Fix For: sprint-2
>
>
> # Need to introduce interface {{CacheObject}} and {{KeyCacheObject}} that
> will hide the implementation details of cached object representation.
> {code}
> public interface CacheObject {
> public <T> T value(GridCacheContext ctx);
> public <T> T getField(String name);
> public byte[] valueBytes();
> }
> public interface KeyCacheObject extends CacheObject {
> public int hashCode();
> }
> {code}
> Implementation of this class must always store serialized form of the object
> and should be optionally store deserialized form of the object. Cache object
> must never keep the original reference of the user object.
> # Inside {{GridCacheMapEntry}} fields {{key}}, {{keyBytes}}, {{value}} and
> {{valueBytes}} should be replaced with corresponding {{CacheObject}}
> references.
> # Same goes for other cache classes that were using keys, values or thereof
> bytes implicitly ({{IgniteTxEntry}}, {{GridCacheEntryInfo}}, etc)
> # Transformation of user object to a cache object in Ignite should be
> implemented in {{GridPortableProcessor}} which should be renamed to
> {{IgniteCacheObjectProcessor}}. {{IgniteCacheSerializarionManager}} should be
> removed.
> # Marshalling of {{CacheObject}} should take advantage of portable
> marshalling mechanism and always use only the serialized bytes stored in the
> {{CacheObject}}. In current implementation {{CacheObjectImpl}} should extend
> {{MessageAdapter}} (UPDATE WILL FOLLOW).
> # {{storeValueBytes}} flag should be removed from configuration.
> # Internal cache API should use {{CacheObject}} exclusively and wrap/unwrap
> it to/from user objects on the very top-level-proxy level (unwrap is for
> sure, wrap is subject to discuss).
> # {{cacheKeyBinaryEquality}} flag should be introduced to cache configuration
> (default true). When true, cache keys should not be deserialized and binary
> form of the object altogether with the hash code should be used to check key
> equality. {{GridCacheConcurrentMap}} should be updated accordingly.
> # {{copyOnGet}} flag should be added to cache configuration (default true).
> When true, new value should be deserialized and returned to user on each
> cache operation implying return value. Ignite should maintain a list of known
> immutable types (such as {{Integer}}, {{String}}) for which {{copyOnGet}} is
> ignored. New annotation {{@IgniteImmutable}} should be introduced to mark
> immutable types for which this flag is also ignored.
> # When indexing is enabled, {{CacheObject}} should always keep deserialized
> version of user object. {{getField()}} method should be used in indexing to
> obtain indexed fields via reflection. {{getField()}} should maintain
> necessary reflection cache to keep current performance level. See
> {{IgniteH2Indexing}} for details.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
