Package com.apple.foundationdb.record.metadata.expressions

Class ElementKeyExpression

java.lang.Object

com.apple.foundationdb.record.metadata.expressions.BaseKeyExpression

com.apple.foundationdb.record.metadata.expressions.ElementKeyExpression

All Implemented Interfaces:

KeyExpression, KeyExpressionWithoutChildren, PlanHashable

@API(EXPERIMENTAL)
public class ElementKeyExpression
extends BaseKeyExpression
implements KeyExpressionWithoutChildren

A key expression that derives its values from an Element.

This key expression is only used in the "planner normalized" key expressions produced by KeyExpression.normalizeForPlanner(Source, List) and is meant to make it easy for methods such as ViewExpression.fromIndexDefinition(java.lang.String, java.util.Collection<java.lang.String>, com.apple.foundationdb.record.metadata.expressions.KeyExpression) to interpret a key expression without dealing with complex rules for nesting and fan-out.

See Also:

KeyExpression.normalizeForPlanner(Source, List)

Nested Class Summary

Nested classes/interfaces inherited from class com.apple.foundationdb.record.metadata.expressions.BaseKeyExpression

BaseKeyExpression.IllegalSubKeyException, BaseKeyExpression.UnsplittableKeyExpressionException

Nested classes/interfaces inherited from interface com.apple.foundationdb.record.metadata.expressions.KeyExpression

KeyExpression.DeserializationException, KeyExpression.FanType, KeyExpression.InvalidExpressionException, KeyExpression.InvalidResultException, KeyExpression.NoSuchArgumentException, KeyExpression.SerializationException

Constructor Summary

Constructors

Constructor	Description
ElementKeyExpression(Element element)

Method Summary

Modifier and Type	Method	Description
boolean	createsDuplicates()	This states whether the given expression type is capable of evaluating more to more than one value when applied to a single record.
<M extends Message> List<Key.Evaluated>	evaluate(FDBRecord<M> record)	Evaluate against a given record producing a list of evaluated keys.
<M extends Message> List<Key.Evaluated>	evaluateMessage(FDBRecord<M> record, Message message)	Evaluate this expression against a record or a Protobuf message.
List<Element>	flattenForPlanner()	Flatten this key expression into a list of Elements, much like KeyExpression.normalizeKeyForPositions().
int	getColumnSize()	Returns the number of items in each KeyValue that will be returned.
Element	getElement()
KeyExpression	normalizeForPlanner(Source source, List<String> fieldNamePrefix)	Normalize this key expression into another key expression that pushes all nesting and fan-out to ElementKeyExpressions at the leaves.
int	planHash()	Return a hash similar to hashCode, but with the additional guarantee that is is stable across JVMs.
RecordMetaDataProto.KeyExpression	toKeyExpression()
Message	toProto()
List<Descriptors.FieldDescriptor>	validate(Descriptors.Descriptor descriptor)	Validate this expression against a given record type descriptor.

Methods inherited from class com.apple.foundationdb.record.metadata.expressions.BaseKeyExpression

getSubKey, getSubKeyImpl, isPrefixKey

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.apple.foundationdb.record.metadata.expressions.KeyExpression

evaluateSingleton, getSubKey, hasProperInterfaces, hasRecordTypeKey, isPrefixKey, normalizeKeyForPositions, versionColumns

Constructor Detail

ElementKeyExpression

public ElementKeyExpression(@Nonnull
                            Element element)

Method Detail

getElement

@Nonnull
public Element getElement()

normalizeForPlanner

@Nonnull
public KeyExpression normalizeForPlanner(@Nonnull
                                         Source source,
                                         @Nonnull
                                         List<String> fieldNamePrefix)

Description copied from interface: KeyExpression

Normalize this key expression into another key expression that pushes all nesting and fan-out to ElementKeyExpressions at the leaves.

By default, a key expression is a complicated nested structure that can be difficult to work with. This method pushes much of the complexity, including nested structures and fan-out of repeated fields, to special key expressions that track these relationship using the Source abstraction. This pre-processing makes planning nested and repeated structures much simpler.

This normalization process requires tracking some state since the name of a nested field is available only at the relevant FieldKeyExpression, but that information is necessary to construct the ElementKeyExpression at the leaves of the sub-tree rooted at the NestingKeyExpression. This extra information is tracked in the fieldNamePrefix.

Specified by:

normalizeForPlanner in interface KeyExpression

Parameters:

source - the source representing the input stream of the key expression

fieldNamePrefix - the (non-repeated) field names on the path from the most recent source to this part of the key expression

Returns:

a new key expression that has only ElementKeyExpressions at its leaves

flattenForPlanner

@Nonnull
public List<Element> flattenForPlanner()

Description copied from interface: KeyExpression

Flatten this key expression into a list of Elements, much like KeyExpression.normalizeKeyForPositions(). By default, this method throws an exception because most key expressions cannot be flattened to a list of elements without prior adjustment. This method is only overriden by key expressions that can be flattened.

Specified by:

flattenForPlanner in interface KeyExpression

Returns:

a list of elements representing this key expression in unnested form

See Also:

flattenForPlanner(), ThenKeyExpression.flattenForPlanner()

evaluate

@Nonnull
public <M extends Message> List<Key.Evaluated> evaluate(@Nullable
                                                        FDBRecord<M> record)

Description copied from interface: KeyExpression

Evaluate against a given record producing a list of evaluated keys. These are extracted from the fields within the record according to the rules of each implementing class. Implementations should override KeyExpression.evaluateMessage(com.apple.foundationdb.record.provider.foundationdb.FDBRecord<M>, com.google.protobuf.Message) instead of this one, even if they do not deal with Protobuf messages, so that they interact properly with expressions that do.

Specified by:

evaluate in interface KeyExpression

Type Parameters:

M - the type of record

Parameters:

record - the record

Returns:

the list of evaluated keys for the given record

evaluateMessage

@Nonnull
public <M extends Message> List<Key.Evaluated> evaluateMessage(@Nullable
                                                               FDBRecord<M> record,
                                                               @Nullable
                                                               Message message)

Description copied from interface: KeyExpression

Evaluate this expression against a record or a Protobuf message. The message might be the Protobuf form of a record or a piece of that record. If the key expression is meaningful against a subrecord, it should evaluate against the message. Otherwise, it should evaluate against the record and ignore what part of that record is being considered. There should not be any reason to call this method outside of the implementation of another evaluateMessage. Under ordinary circumstances, if record is null, then message will be null. Otherwise, message will be record.getRecord() or some submessage of that, possibly null if the corresponding field is missing.

Specified by:

evaluateMessage in interface KeyExpression

Type Parameters:

M - the type of record

Parameters:

record - the record

message - the Protobuf message to evaluate against

Returns:

the evaluated keys for the given record

See Also:

KeyExpression.evaluate(com.apple.foundationdb.record.provider.foundationdb.FDBRecord<M>)

createsDuplicates

public boolean createsDuplicates()

Description copied from interface: KeyExpression

This states whether the given expression type is capable of evaluating more to more than one value when applied to a single record. In practice, this can happen if this expression is evaluated on a repeated field with FanType.FanOut set (either directly or indirectly).

Specified by:

createsDuplicates in interface KeyExpression

Returns:

true if this expression can evaluate to multiple values and false otherwise

validate

public List<Descriptors.FieldDescriptor> validate(@Nonnull
                                                  Descriptors.Descriptor descriptor)

Description copied from interface: KeyExpression

Validate this expression against a given record type descriptor.

Specified by:

validate in interface KeyExpression

Parameters:

descriptor - the descriptor for the record type or submessage

Returns:

a list of fields that this key applies to

getColumnSize

public int getColumnSize()

Description copied from interface: KeyExpression

Returns the number of items in each KeyValue that will be returned. For key expressions that support KeyExpression.FanType.Concatenate, this will the count of non-nested lists, i.e. this will be value of evaluate(r).get(i).toList().size() for any i or r.

Specified by:

getColumnSize in interface KeyExpression

Returns:

the number of elements that will be produced for every key

toProto

@Nonnull
public Message toProto()
                throws KeyExpression.SerializationException

Specified by:

toProto in interface KeyExpression

Throws:

KeyExpression.SerializationException

toKeyExpression

@Nonnull
public RecordMetaDataProto.KeyExpression toKeyExpression()

Specified by:

toKeyExpression in interface KeyExpression

planHash

public int planHash()

Description copied from interface: PlanHashable

Return a hash similar to hashCode, but with the additional guarantee that is is stable across JVMs.

Specified by:

planHash in interface PlanHashable

Returns:

a stable hash code