|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
public static interface AbstractTripleStore.Options
Configuration options.
| Field Summary | |
|---|---|
static String |
AXIOMS_CLASS
The Axioms model that will be used (default
). |
static String |
BLOBS_THRESHOLD
The threshold (in character length) at which an RDF Value
will be inserted into the LexiconKeyOrder.BLOBS index rather
than the LexiconKeyOrder.TERM2ID and
LexiconKeyOrder.ID2TERM indices (default
"256"). |
static String |
BLOOM_FILTER
Optional property controls whether or not a bloom filter is maintained for the SPO statement index. |
static String |
CLOSURE_CLASS
The name of the BaseClosure class that will be used (default
). |
static String |
CONSTRAIN_XXXC_SHARDS
Boolean option determines whether or not an XXXCShardSplitHandler is applied (scale-out only, default
"true"). |
static String |
DEFAULT_AXIOMS_CLASS
|
static String |
DEFAULT_BLOBS_THRESHOLD
|
static String |
DEFAULT_BLOOM_FILTER
|
static String |
DEFAULT_CLOSURE_CLASS
|
static String |
DEFAULT_CONSTRAIN_XXXC_SHARDS
|
static String |
DEFAULT_EXTENSION_FACTORY_CLASS
|
static String |
DEFAULT_INLINE_BNODES
|
static String |
DEFAULT_INLINE_DATE_TIMES
|
static String |
DEFAULT_INLINE_DATE_TIMES_TIMEZONE
|
static String |
DEFAULT_INLINE_TEXT_LITERALS
|
static String |
DEFAULT_INLINE_XSD_DATATYPE_LITERALS
|
static String |
DEFAULT_JUSTIFY
|
static String |
DEFAULT_LEXICON
|
static String |
DEFAULT_MAX_INLINE_STRING_LENGTH
Note that there an interaction when this is enabled with the full text indexer. |
static String |
DEFAULT_ONE_ACCESS_PATH
|
static String |
DEFAULT_QUADS
|
static String |
DEFAULT_QUADS_MODE
|
static String |
DEFAULT_REJECT_INVALID_XSD_VALUES
|
static String |
DEFAULT_STATEMENT_IDENTIFIERS
|
static String |
DEFAULT_STORE_BLANK_NODES
|
static String |
DEFAULT_SUBJECT_CENTRIC_TEXT_INDEX
|
static String |
DEFAULT_SUBJECT_CENTRIC_TEXT_INDEXER_CLASS
|
static String |
DEFAULT_TERM_CACHE_CAPACITY
|
static String |
DEFAULT_TERMID_BITS_TO_REVERSE
|
static String |
DEFAULT_TEXT_INDEX
|
static String |
DEFAULT_TEXT_INDEX_DATATYPE_LITERALS
|
static String |
DEFAULT_TEXT_INDEXER_CLASS
|
static String |
DEFAULT_TRIPLES_MODE
|
static String |
DEFAULT_TRIPLES_MODE_WITH_PROVENANCE
|
static String |
DEFAULT_VALUE_FACTORY_CLASS
|
static String |
DEFAULT_VOCABULARY_CLASS
Note: The default Vocabulary class may be changed from time
to time as additional VocabularyDecl are created and bundled
into a new default Vocabulary. |
static String |
EXTENSION_FACTORY_CLASS
The name of the IExtensionFactory class. |
static String |
INLINE_BNODES
Set up database to inline bnodes directly into the statement indices rather than using the lexicon to map them to term identifiers and back. |
static String |
INLINE_DATE_TIMES
Set up database to inline date/times directly into the statement indices rather than using the lexicon to map them to term identifiers and back (default "true"). |
static String |
INLINE_DATE_TIMES_TIMEZONE
The default time zone to be used to a) encode inline xsd:datetime literals that do not have a time zone specified and b) decode xsd:datetime literals from the statement indices where they are stored as UTC milliseconds since the epoch (default "GMT"). |
static String |
INLINE_TEXT_LITERALS
Inline ANY literal having fewer than MAX_INLINE_TEXT_LENGTH
characters (default "false"). |
static String |
INLINE_XSD_DATATYPE_LITERALS
Set up database to inline XSD datatype literals corresponding to primitives (boolean) and numerics (byte, short, int, etc) directly into the statement indices (default "true"). |
static String |
JUSTIFY
When true (default ),
proof chains for entailments generated by forward chaining are stored
in the database. |
static String |
LEXICON
Boolean option (default true) enables support for the
lexicon (the forward and backward term indices). |
static String |
MAX_INLINE_TEXT_LENGTH
The maximum length of a String value which may be inlined into the statement indices (default "0" ). |
static String |
ONE_ACCESS_PATH
Boolean option (default false) disables all but a
single statement index (aka access path). |
static String |
QUADS
Boolean option determines whether the KB instance will be a quad store or a triple store. |
static String |
QUADS_MODE
Set up database in quads mode. |
static String |
REJECT_INVALID_XSD_VALUES
When true AND is
true, literals having an xsd datatype URI which can not
be validated against that datatype will be rejected (default
DEFAULT_REJECT_INVALID_XSD_VALUES). |
static String |
STATEMENT_IDENTIFIERS
Boolean option (default "false") enables support for statement identifiers. |
static String |
STORE_BLANK_NODES
Boolean option (default "false") controls whether or not we store blank nodes in the forward mapping of the lexicon (this is also known as the "told bnodes" mode). |
static String |
SUBJECT_CENTRIC_TEXT_INDEX
Boolean option (default true) enables support for a
full text index that may be used to lookup literals by tokens found
in the text of those literals. |
static String |
SUBJECT_CENTRIC_TEXT_INDEXER_CLASS
The name of the ITextIndexer class. |
static String |
TERM_CACHE_CAPACITY
Integer option whose value is the capacity of the term cache. |
static String |
TERMID_BITS_TO_REVERSE
Option effects how evenly distributed the assigned term identifiers which has a pronounced effect on the ID2TERM and statement indices for scale-out deployments. |
static String |
TEXT_INDEX
Boolean option (default "true") enables support for a full text index that may be used to lookup literals by tokens found in the text of those literals. |
static String |
TEXT_INDEX_DATATYPE_LITERALS
Boolean option enables support for a full text index that may be used to lookup datatype literals by tokens found in the text of those literals (default "true"). |
static String |
TEXT_INDEXER_CLASS
The name of the IValueCentricTextIndexer class. |
static String |
TRIPLES_MODE
Set up database in triples mode, no provenance. |
static String |
TRIPLES_MODE_WITH_PROVENANCE
Set up database in triples mode with provenance. |
static String |
VALUE_FACTORY_CLASS
The name of the BigdataValueFactory class. |
static String |
VOCABULARY_CLASS
The name of the class that will establish the pre-defined Vocabulary for the database (default
). |
| Fields inherited from interface com.bigdata.btree.keys.KeyBuilder.Options |
|---|
COLLATOR, DECOMPOSITION, STRENGTH, USER_COUNTRY, USER_LANGUAGE, USER_VARIANT |
| Fields inherited from interface com.bigdata.rdf.store.DataLoader.Options |
|---|
BUFFER_CAPACITY, CLOSURE, COMMIT, DEFAULT_BUFFER_CAPACITY, DEFAULT_CLOSURE, DEFAULT_COMMIT, DEFAULT_FLUSH, FLUSH |
| Fields inherited from interface com.bigdata.rdf.rio.RDFParserOptions.Options |
|---|
DATATYPE_HANDLING, DEFAULT_DATATYPE_HANDLING, DEFAULT_PRESERVE_BNODE_IDS, DEFAULT_STOP_AT_FIRST_ERROR, DEFAULT_VERIFY_DATA, PRESERVE_BNODE_IDS, STOP_AT_FIRST_ERROR, VERIFY_DATA |
| Field Detail |
|---|
static final String LEXICON
true) enables support for the
lexicon (the forward and backward term indices). When
false, the lexicon indices are not registered. This can
be safely turned off for the TempTripleStore when only the
statement indices are to be used.
You can control how the triple store will interpret the RDF URIs, and
literals using the KeyBuilder.Options. For example:
// Force ASCII key comparisons. properties.setProperty(Options.COLLATOR, CollatorEnum.ASCII.toString());or
// Force identical unicode comparisons (assuming default COLLATOR setting). properties.setProperty(Options.STRENGTH, StrengthEnum.IDENTICAL.toString());
LexiconRelation,
KeyBuilder.Optionsstatic final String DEFAULT_LEXICON
static final String STORE_BLANK_NODES
When false blank node semantics are enforced, you CAN
NOT unify blank nodes based on their IDs in the lexicon, and
AbstractTripleStore.getBNodeCount() is disabled.
When true, you are able to violate blank node semantics
and force unification of blank nodes by assigning the ID from the RDF
interchange syntax to the blank node. RIO has an option that will
allow you to do this. When this option is also true,
then you will in fact be able to resolve pre-existing blank nodes
using their identifiers. The tradeoff is time and space : if you have
a LOT of document using blank nodes then you might want to disable
this option in order to spend less time writing the forward lexicon
index (and it will also take up less space).
static final String DEFAULT_STORE_BLANK_NODES
static final String TERMID_BITS_TO_REVERSE
For the scale-out triple store, the term identifiers are formed by placing the index partition identifier in the high word and the local counter for the index partition into the low word. The effect of this option is to cause the low N bits of the local counter value to be reversed and written into the high N bits of the term identifier (the other bits are shifted down to make room for this). Regardless of the configured value for this option, all bits of the both the partition identifier and the local counter are preserved.
Normally, the low bits of a sequential counter will vary the most rapidly. By reversing the localCounter and placing some of the reversed bits into the high bits of the term identifier we cause the term identifiers to be uniformly (but not randomly) distributed. This is much like using hash function without collisions or a random number generator that does not produce duplicates. When the value of this option is ZERO (0), no bits are reversed so the high bits of the term identifiers directly reflect the partition identifier and the low bits are assigned sequentially by the local counter within each TERM2ID index partition.
The use of a non-zero value for this option can easily cause the write load on the index partitions for the ID2TERM and statement indices to be perfectly balanced. However, using too many bits has some negative consequences on locality of operations within an index partition (since the distribution of the keys be approximately uniform distribution, leading to poor cache performance, more copy-on-write for the B+Tree, and both more IO and faster growth in the journal for writes (since there will be more leaves made dirty on average by each bulk write)).
The use of a non-zero value for this option also directly effects the degree of scatter for bulk read or write operations. As more bits are used, it becomes increasingly likely that each bulk read or write operation will on average touch all index partitions. This is because #of low order local counter bits reversed and rotated into the high bits of the term identifier places an approximate bound on the #of index partitions of the ID2TERM or a statement index that will be touched by a scattered read or write. However, that number will continue to grow slowly over time as new partition identifiers are introduced (the partition identifiers appear next in the encoded term identifier and therefore determine the degree of locality or scatter once the quickly varying high bits have had their say).
The "right" value really depends on the expected scale of the knowledge base. If you estimate that you will have 50 x 200M index partitions for the statement indices, then SQRT(50) =~ 7 would be a good choice.
TermIdEncoderstatic final String DEFAULT_TERMID_BITS_TO_REVERSE
static final String TERM_CACHE_CAPACITY
Values by
their term identifier.
static final String DEFAULT_TERM_CACHE_CAPACITY
static final String VOCABULARY_CLASS
Vocabulary for the database (default
). The class MUST extend
BaseVocabulary. This option is ignored if the lexicon is
disabled.
The Vocabulary is initialized by
AbstractTripleStore.create(). Its state is stored in the
global row store under the TripleStoreSchema.VOCABULARY
property. The named Vocabulary class will be used to
instantiate a consistent vocabulary mapping each time a view of the
AbstractTripleStore is materialized. This depends on the
named Vocabulary class having a stable behavior. Thus the
BaseVocabulary class builds in protection against version
changes and will refuse to materialize a view of the
AbstractTripleStore if the Vocabulary would not be
consistent.
The BaseVocabulary class is designed for easy and modular
extension. You can trivially define a concrete instance of this class
which provides any (reasonable) number of VocabularyDecl
instances. Each VocabularyDecl declares the namespace(s) and
the URIs for some ontology. A number of such classes have
been created and are combined by the
DEFAULT_VOCABULARY_CLASS. You can create your own
VocabularyDecl classes and combine them within your own
Vocabulary, but it must extend BaseVocabulary.
Note: There is an interaction between the Vocabulary and
IExtensions. The IDatatypeURIResolver requires that
URIs used by an IExtension are pre-declared by the
Vocabulary.
static final String DEFAULT_VOCABULARY_CLASS
Vocabulary class may be changed from time
to time as additional VocabularyDecl are created and bundled
into a new default Vocabulary. However, a deployed concrete
instance of the default Vocabulary class MUST NOT be modified
since that could introduce inconsistencies into the URI to IV mapping
which it provides for AbstractTripleStores created using that
class.
static final String AXIOMS_CLASS
Axioms model that will be used (default
). The value is the name of the
class that will be instantiated by
AbstractTripleStore.create(). The class must extend
BaseAxioms. This option is ignored if the lexicon is
disabled. Use NoAxioms to disable inference.
static final String DEFAULT_AXIOMS_CLASS
static final String CLOSURE_CLASS
BaseClosure class that will be used (default
). The value is the name of
the class that will be used to generate the Program that
computes the closure of the database. The class must extend
BaseClosure. This option is ignored if the inference is
disabled.
There are two pre-defined "programs" used to compute and maintain
closure. The FullClosure program is a simple fix point of the
RDFS+ entailments, except for the
foo rdf:type rdfs:Resource entailments which are
normally generated at query time. The FastClosure program
breaks nearly all cycles in the RDFS rules and runs nearly entirely
as a sequence of IRules, including several custom rules.
It is far easier to modify the FullClosure program since any
new rules can just be dropped into place. Modifying the
FastClosure program requires careful consideration of the
entailments computed at each stage in order to determine where a new
rule would fit in.
Note: When support for owl:sameAs, etc. processing is
enabled, some of the entailments are computed by rules run during
forward closure and some of the entailments are computed by rules run
at query time. Both FastClosure and FullClosure are
aware of this and handle it correctly (e.g., as configured).
static final String DEFAULT_CLOSURE_CLASS
static final String ONE_ACCESS_PATH
false) disables all but a
single statement index (aka access path).
Note: The main purpose of the option is to make it possible to turn
off the other access paths for special bulk load purposes. The use of
this option is NOT compatible with either the application of the
InferenceEngine or high-level query.
Note: You may want to explicitly enable or disable the bloom filter
for this. Normally a single access path (SPO) is used for a temporary
store. Temporary stores tend to be smaller, so if you will also be
doing point tests on the temporary store then you probably want to
use the BLOOM_FILTER. Otherwise it may be turned off to
realize some (minimal) performance gain.
static final String DEFAULT_ONE_ACCESS_PATH
static final String BLOOM_FILTER
AbstractBTrees. While the mutable BTrees might
occasionally grow too large to support a bloom filter, data is
periodically migrated onto immutable IndexSegments which have
perfect fit bloom filters. This means that the bloom filter
scales-out, but not up.
Note: The SPO access path is used any time we have an access path that corresponds to a point test. Therefore this is the only index for which it makes sense to maintain a bloom filter.
If you are going to do a lot of small commits, then please DO NOT
enable the bloom filter for the AbstractTripleStore. The
bloom filter takes 1 MB each time you commit on the SPO/SPOC index.
The bloom filter limited value in any case for scale-up since its
nominal error rate will be exceeded at ~2M triples. This concern does
not apply for scale-out, where the bloom filter is always a good
idea.
IndexMetadata.getBloomFilterFactory()static final String DEFAULT_BLOOM_FILTER
static final String JUSTIFY
true (default ),
proof chains for entailments generated by forward chaining are stored
in the database. This option is required for truth maintenance when
retracting assertion.
If you will not be retracting statements from the database then you
can specify false for a significant performance boost
during writes and a smaller profile on the disk.
This option does not effect query performance since the justifications are maintained in a distinct index and are only used when retracting assertions.
static final String DEFAULT_JUSTIFY
static final String STATEMENT_IDENTIFIERS
Statement identifiers are assigned consistently when Statement
s are mapped into the database. This is done using an extension of
the term:id index to map the statement as if it were a
term onto a unique statement identifier. While the statement
identifier is assigned canonically by the term:id index,
it is stored redundantly in the value position for each of the
statement indices. While the statement identifier is, in fact, a term
identifier, the reverse mapping is NOT stored in the id:term index
and you CAN NOT translate from a statement identifier back to the
original statement.
bigdata supports an RDF/XML interchange extension for the interchange
of triples with statement identifiers that may be used as
blank nodes to make statements about statements. See BD and
RDFXMLParser.
Statement identifiers add some latency when loading data since it increases the size of the writes on the terms index (and also its space requirements since all statements are also replicated in the terms index). However, if you are doing concurrent data load then the added latency is nicely offset by the parallelism.
The main benefit for statement identifiers is that they provide a mechanism for statement level provenance. This is critical for some applications.
An alternative approach to provenance within RDF is to use the concatenation of the subject, predicate, and object (or a hash of their concatenation) as the value in the context position. While this approach can be used with any quad store, it is less transparent and requires twice the amount of data on the disk since you need an additional three statement indices to cover the quad access paths.
The provenance mode (SIDs) IS NOT compatible with the QUADS
mode. You may use either one, but not both in the same KB instance.
There are examples for using the provenance mode online.
static final String DEFAULT_STATEMENT_IDENTIFIERS
static final String QUADS
STATEMENT_IDENTIFIERS option determines whether or not the
provenance mode is enabled.
static final String DEFAULT_QUADS
static final String TRIPLES_MODE
QUADS
= falseSTATEMENT_IDENTIFIERS
= false
static final String DEFAULT_TRIPLES_MODE
static final String TRIPLES_MODE_WITH_PROVENANCE
QUADS
= falseSTATEMENT_IDENTIFIERS
= true
static final String DEFAULT_TRIPLES_MODE_WITH_PROVENANCE
static final String QUADS_MODE
QUADS
= trueSTATEMENT_IDENTIFIERS
= falseAXIOMS_CLASS
= com.bigdata.rdf.store.AbstractTripleStore.NoAxioms
static final String DEFAULT_QUADS_MODE
static final String VALUE_FACTORY_CLASS
BigdataValueFactory class. The implementation
MUST declare a method with the following signature which will be used
as a canonicalizing factory for the instances of that class.
public static BigdataValueFactory getInstance(final String namespace)
DEFAULT_VALUE_FACTORY_CLASSstatic final String DEFAULT_VALUE_FACTORY_CLASS
static final String TEXT_INDEX
TEXT_INDEXER_CLASS,
TEXT_INDEX_DATATYPE_LITERALS,
INLINE_TEXT_LITERALS,
MAX_INLINE_TEXT_LENGTHstatic final String DEFAULT_TEXT_INDEX
static final String SUBJECT_CENTRIC_TEXT_INDEX
true) enables support for a
full text index that may be used to lookup literals by tokens found
in the text of those literals.
TEXT_INDEXER_CLASS,
TEXT_INDEX_DATATYPE_LITERALS,
INLINE_TEXT_LITERALS,
MAX_INLINE_TEXT_LENGTHstatic final String DEFAULT_SUBJECT_CENTRIC_TEXT_INDEX
static final String TEXT_INDEX_DATATYPE_LITERALS
xsd:string,
xsd:int, etc.
static final String DEFAULT_TEXT_INDEX_DATATYPE_LITERALS
static final String TEXT_INDEXER_CLASS
IValueCentricTextIndexer class. The implementation MUST
declare a method with the following signature which will be used to
locate instances of that class.
static public ITextIndexer getInstance(final IIndexManager indexManager,
final String namespace, final Long timestamp,
final Properties properties)
DEFAULT_TEXT_INDEXER_CLASSstatic final String DEFAULT_TEXT_INDEXER_CLASS
static final String SUBJECT_CENTRIC_TEXT_INDEXER_CLASS
ITextIndexer class. The implementation MUST
declare a method with the following signature which will be used to
locate instances of that class.
static public ITextIndexer getInstance(final IIndexManager indexManager,
final String namespace, final Long timestamp,
final Properties properties)
DEFAULT_TEXT_INDEXER_CLASSstatic final String DEFAULT_SUBJECT_CENTRIC_TEXT_INDEXER_CLASS
static final String BLOBS_THRESHOLD
Value
will be inserted into the LexiconKeyOrder.BLOBS index rather
than the LexiconKeyOrder.TERM2ID and
LexiconKeyOrder.ID2TERM indices (default
"256").
The LexiconKeyOrder.BLOBS index is capable of storing very
large literals but has more IO scatter due to the hash code component
of the key for that index. Therefore smaller RDF Values
should be inserted into the LexiconKeyOrder.TERM2ID and
LexiconKeyOrder.ID2TERM indices while very large RDF
Values MUST be inserted into the
LexiconKeyOrder.BLOBS index.
The LexiconKeyOrder.TERM2ID index keys are Unicode sort codes
based on the RDF Values. This threshold essentially limits
the maximum length of the keys in the LexiconKeyOrder.TERM2ID
index.
static final String DEFAULT_BLOBS_THRESHOLD
static final String INLINE_XSD_DATATYPE_LITERALS
Note: xsd:dateTime inlining is controlled by a distinct
option. See INLINE_DATE_TIMES.
Note: xsd:string inlining and the inlining of non-xsd
literals are controlled by INLINE_TEXT_LITERALS and
MAX_INLINE_TEXT_LENGTH.
static final String DEFAULT_INLINE_XSD_DATATYPE_LITERALS
static final String INLINE_TEXT_LITERALS
MAX_INLINE_TEXT_LENGTH
characters (default "false").
Note: This option exists mainly to support a scale-out design in which everything is inlined into the statement indices. This design is similar to the YARS2 system with its ISAM files and has the advantage that little or nothing is stored within the lexicon.
Inlining of large literals via this option is NOT compatible with
TEXT_INDEX. The problem is that we need to index literals
which are inlined as well as those which are not inlined. While the
full text index does support this, indexing fully inline literals
only makes sense for reasonably short literals. This is because the
IV of the inlined literal (a) embeds its (compressed) Unicode
representation; and (b) is replicated for each token within that
literal. For large literals, this causes a substantial expansion in
the full text index.
static final String DEFAULT_INLINE_TEXT_LITERALS
static final String MAX_INLINE_TEXT_LENGTH
XSDStringExtension is registered by the
DefaultExtensionFactory when GT ZERO (0).
Note: URIs may be readily inlined using this mechanism without
causing an interaction with the full text index since they are not
indexed by the full text index. However, inlining literals in this
manner causes the Unicode representation of the literal to be
duplicated within the full text index for each token in that literal.
See TEXT_INDEX and INLINE_TEXT_LITERALS.
DefaultExtensionFactorystatic final String DEFAULT_MAX_INLINE_STRING_LENGTH
static final String INLINE_BNODES
See STORE_BLANK_NODES.
static final String DEFAULT_INLINE_BNODES
static final String INLINE_DATE_TIMES
INLINE_DATE_TIMES_TIMEZONEstatic final String DEFAULT_INLINE_DATE_TIMES
static final String INLINE_DATE_TIMES_TIMEZONE
INLINE_DATE_TIMESstatic final String DEFAULT_INLINE_DATE_TIMES_TIMEZONE
INLINE_DATE_TIMES_TIMEZONE,
Constant Field Valuesstatic final String EXTENSION_FACTORY_CLASS
IExtensionFactory class. The implementation
MUST declare a constructor that accepts an
IDatatypeURIResolver as its only argument. The
IExtensions constructed by the factory need a resolver to
resolve datatype URIs to term identifiers in the database.
DEFAULT_EXTENSION_FACTORY_CLASSstatic final String DEFAULT_EXTENSION_FACTORY_CLASS
static final String REJECT_INVALID_XSD_VALUES
true AND is
true, literals having an xsd datatype URI which can not
be validated against that datatype will be rejected (default
DEFAULT_REJECT_INVALID_XSD_VALUES). For example, when
true abc^^xsd:int would be rejected. When
false the literal will be accepted, but it will not be
inlined with the rest of the literals for that value space and will
typically encounter an SPARQL type error during query evaluation.
static final String DEFAULT_REJECT_INVALID_XSD_VALUES
static final String CONSTRAIN_XXXC_SHARDS
XXXCShardSplitHandler is applied (scale-out only, default
"true").
When true, shards whose SPOKeyOrder name ends
with "C" are constrained such that all quads for the same triple will
be co-located on the same shard. This constraint allows certain
optimizations for default graph handling.
This constraint may be used if you do not expect to have more than ~200MB worth of distinct graphs within which the same triple may be asserted. This is a soft constraint as larger shards are permitted, but performance will degrade if this constraint forces some shards to be many times larger than their nominal capacity.
XXXCShardSplitHandlerstatic final String DEFAULT_CONSTRAIN_XXXC_SHARDS
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||