The primary key that uniquely identifies each item in a table. A primary key can be a one attribute (hash) primary key or a two attribute (hash-and-range) primary key.
A key for retrieving entities from a {@link RandomAccessDataset}.
@since 0.9.0The key object; this class is take from the app-engine datastore (mostly) implementation. It is also Serializable and GWT-safe, enabling your entity objects to be used for GWT RPC should you so desire.
You may use normal DBRef objects as relationships in your entities if you desire neither type safety nor GWTability.
@author Jeff SchnitzerThis is a typesafe version of the Key object. It is also Serializable and GWT-safe, enabling your entity objects to be used for GWT RPC should you so desire.
You may use normal Key objects as relationships in your entities if you desire neither type safety nor GWTability.
@author Jeff SchnitzerThe default string-encoding algorithm does not support localized collation. TODO - add collation information here - TODO
Persistit offers built-in support for encoding and decoding of a few commonly used Object types. These include:
java.lang.String java.math.BigInteger java.math.BigDecimal java.util.Date byte[](Note that for byte array, a zero-valued bytes are converted to two-byte sequences, as described above for strings.)
The default encoding for these types, plus any additional Object types that are required to be used as key values, can be overridden by a custom {@link com.persistit.encoding.KeyCoder}. For consistency, the application should register all custom KeyCoder objects immediately after initializing Persistit, for example: Persistit.initialize(); KeyCoder coder = new MyKeyCoder(); Persistit.getInstance().getCoderManager() .registerKeyCoder(MyClass.class, coder);
An application may append multiple values to a Key, each of which is called a key segment. Applications use multiple segments to form concatenated keys. A concatenated key uniquely identifies a particular record by a combination of data values rather than one simple value. The number of segments in a Persistit concatenated key is bounded only by the architectural limitation on the length of the underlying byte array.
Key encodes strings, byte arrays, and all other data types that might naturally contain a zero- valued byte by inserting escape sequences in place of the zero values. Specifically, NUL (character code 0) in a string, or a zero in a byte array element is replaced by the two-byte sequence (0x01, 0x20). An SOH (character code 1) or a one in a byte array element is replaced by the two-byte sequence (0x01, 0x021). This scheme is handled automatically, and only those applications that manipulate the raw byte buffer using the low-level API need to be aware of it. This encoding ensures that the key orderering preserves the natural ordering of the underlying values. For example, the encoded forms of the two string "AB" and "ABC" are (0x80, 0x41, 0x42, 0x00) and (0x80, 0x41, 0x42, 0x43, 0x00), respectively. The two encodings differ in the third byte (the zero that terminates the shorter string) which correctly causes the shorter string to collate before the longer one. Segments fall naturally into the ordering scheme. If two keys are different, then the first segment that differs between the two keys controls their ordering. For example, the code fragment key1.clear().append(1).append(1); key2.clear().append(1).append(2); key3.clear().append(2).append(1); key4.clear().append(2).append(1).append(0);
key1 < key2 < key3 < key4.
The ability to append multiple key segments to a Key supports a method of grouping records logically by hierarchical key values. Much as a paper filing system uses cabinets, drawers, and folders to organize documents, segmented keys can be used to impose a hierarchical organization on data. For example, the key for a purchase order record might have a single segment representing the purchase order number. The purchase order's subsidiary line items might then be stored with keys that are logical children of the purchase order number, as suggested in this code snippet: PurchaseOrderSummary poSummary = ... List poLineItems = ... ... exchange.getValue().put(poSummary) exchange.clear().append(poSummary.getPurchaseOrderNumber()).store(); .. exchange.append(Key.BEFORE); for (Iterator items = poLineItems.iterator(); items.hasMore();) { LineItem item = (LineItem)lineItems.next(); exchange.getValue().set(item); exchange.clear().to(item.getLineItemId()).store(); } ...
Logical child relationships between keys are represented solely by the way in which keys are encoded and ordered within the physical tree; there is no direct physical representation of the logical hierarchy. However, because of the way keys are physically ordered within a Tree, logical child keys fall closer to their parents in key sort order than other keys, and are therefore more likely to be located on physical database pages that have already been read into the buffer pool.
Two families of methods of methods in {@link Exchange} incorporate logic tohandle logical child keys in a special way:
Tree, regardless of whether it is a logical child key. However, if shallow traversal is requested, all logical children are skipped and the result is the next (or previous) logical sibling key value.remove method can remove just the line items, just the purchase order summary, or both.At times it is convenient to represent a Key value as a String, for example, to display it or enter it for editing. This class provides an implementation of {@link #toString} that creates a canonical String representation of a key.The {@link KeyParser#parseKey} method provides the inverse functionality,parsing a canonical string representation to create a key value.
The String representation is of the form:
{ segment,... } where each segment value is one of the following: nullfalsetrue Key key = new Key(); key.append("xyz").append(1.23).append((long)456).append(new Date()); System.out.println(key.toString()); { "xyz", 1.23, (long) 456, (java.util.Date) 20040901114722.563 + 0500 } All numeric types other than double and int use a cast segment representation so to permit exact translation to and from the String representation and the underlying internal key value. The canonical representation of a Date is designed to allow exact translation to and from the internal segment value while being somewhat legible. Applications do two fundamental things with Keys:
Methods used to construct key values are {@link #clear}, {@link #setDepth}, {@link #cut}, {@link #append(boolean)}, {@link #append(byte)}, {@link #append(short)} ... {@link #append(Object)}, {@link #to(boolean)}, {@link #to(byte)} {@link #to(short)} ... {@link #to(Object)}. These methods all modify the current state of the key. As a convenience, these methods all return the Key to support method call chaining.
Methods used to decode key values are {@link #reset}, {@link #indexTo}, {@link #decodeBoolean}, {@link #decodeByte}, {@link #decodeShort} ...{@link #decode}. These methods do not modify the value represented by the key. Each decodeTTTT method returns a value of type TTTT. The {@link #decode} method returns a value of typeObject. The reset and indexTo control which segment the next value will be decoded from.
The low-level API allows an application to bypass the encoding and decoding operations described above and instead to operate directly on the byte array used as the physical B-Tree key. This might be appropriate for an existing application that has already implemented its own serialization mechanisms, for example, or to accommodate special key manipulation requirements. Applications should use these methods only if there is a compelling requirement.
The low-level API methods are:
byte[] {@link #getEncodedBytes}int {@link #getEncodedSize}void {@link #setEncodedSize(int)}
@version 1.0
The interface Key describes a generic object, which somehow represents an encryption or signature key.
Note, that no methods are defined for this, because this depends on the actual implementation.
However, you will receive a reference to a Key within the Packager so that you can simply pass the reference to the encryption system.
This interface extends {@link eu.stratosphere.types.Value} and requires to implementthe serialization of its value. @see eu.stratosphere.types.Value @see eu.stratosphere.core.io.IOReadableWritable @see java.lang.Comparable
This is the name of the format of the encoded key. It is returned by the {@link #getFormat() getFormat} method.
Keys are generally obtained through key generators, certificates, or various Identity classes used to manage keys. Keys may also be obtained from key specifications (transparent representations of the underlying key material) through the use of a key factory (see {@link KeyFactory}).
A Key should use KeyRep as its serialized representation. Note that a serialized Key may contain sensitive information which should not be exposed in untrusted environments. See the Security Appendix of the Serialization Specification for more information. @see PublicKey @see PrivateKey @see KeyPair @see KeyPairGenerator @see KeyFactory @see KeyRep @see java.security.spec.KeySpec @see Identity @see Signer @version 1.57 06/04/21 @author Benjamin Renaud
This interface extends {@link org.apache.flink.types.Value} and requires to implementthe serialization of its value. @see org.apache.flink.types.Value @see org.apache.flink.core.io.IOReadableWritable @see java.lang.Comparable
Note that exposing the state of instances through arrays is a deliberate decision for the sake of performance. The contents of these arrays must not be modified by the caller. @author Gunnar Morling
A key for retrieving entities from a {@link RandomAccessDataset}.
@since 0.9.0The key object; this class is take from the app-engine datastore (mostly) implementation. It is also Serializable and GWT-safe, enabling your entity objects to be used for GWT RPC should you so desire.
You may use normal DBRef objects as relationships in your entities if you desire neither type safety nor GWT-ability.
@author Jeff SchnitzerObject representing a job or trigger key.
@author Jeffrey Wescott | |
| |
| |
| |
| |
| |
| |
| |
| |
| |