# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.  

rel-to-unknownid: You cannot map a logical foreign key relation to an object \
	with an unknown identity type.
cant-mapped-by: Field "{0}" cannot declare that it is mapped by another field. \
	Its mapping strategy ({1}) does not support mapping by another field.
mapped-inverse-unjoined: Field "{0}" as defined in "{1}" cannot be mapped by \
	"{2}".  You cannot use an inverse foreign key to map a superclass field of \
	an unjoined subclass.
mapped-by-unmapped: Field "{0}" cannot be mapped by "{1}", because the related \
	field or type is unmapped.
cant-join: Cannot join across "{0}".  The related type has unjoined subclasses.
cant-inverse: "{0}" is not a valid mapping.  Inverse foreign key-based \
	relations to types with unjoined subclasses are not supported.
cant-load: "{0}" is not a valid mapping. The related type has subclasses that \
	are not reachable via joins, so OpenJPA must be able to construct an oid \
	from the mapped foreign key.  But your foreign key does not represent all \
	primary key values of the related type.
flush-virtual: Attempt to flush an unmapped object of type "{0}" with oid "{1}".
cant-project-owned: "{0}" cannot be used in a projection, because it can only \
	be loaded as part of its owning object.
not-embeddable: "{0}" is mapped as embedded, but embedded field "{1}" is not \
	embeddable.  Embedded element/key/value types are limited to simple fields \
	and direct relations to other persistent types.
oid-invalid: Object id data "{0}" loaded from the database for "{1}" is not in \
	the correct format. Please ensure that your database records are in the \
	correct format.
lrs-no-owner: This container was loaded in large result set field "{0}", but \
	has been removed from its owning field.  Therefore, it can no longer be \
	used.
not-full: Type "{0}" specifies a full class mapping strategy, but has a mapped \
	persistence capable superclass or is embedded.  Use a valid subclass or \
	embedded strategy instead.
not-base-vers: Type "{0}" specifies a version strategy, but has a mapped \
	persistence capable superclass or is embedded.  Subclasses and embedded \
	values must use the version strategy of the base or embedding class.
not-base-disc: Type "{0}" specifies a discriminator strategy, but has a mapped \
	persistence capable superclass or is embedded.  Subclasses and embedded \
	values must use the discriminator strategy of the base or embedding class.
not-sub: Type "{0}" specifies a subclass mapping strategy, but does not \
	have a mapped persistence capable superclass or is embedded.  Use a valid \
	base or embedded class strategy instead.
not-embed: "{0}" specifies an embedded mapping strategy, but it is not \
	embedded.
not-oid: "{0}" species an object id mapping strategy, but it is not \
	an object id field.
flat-table: Type "{0}" uses a flat inheritance mapping, but declares a table \
	name of "{1}", which does not match the superclass table "{2}".
not-string: Field "{0}" declares a string field mapping strategy, but is not \
	a string field.
not-primitive: Field "{0}" declares a primitive field mapping strategy, but \
	is not of a primitive type.
not-clobstring: Field "{0}" declares a clob field mapping strategy, but is \
	not a string field.
not-bytes: Field "{0}" declares a byte array field mapping strategy, but is \
	not a byte array field.
not-chars: Field "{0}" declares a char array field mapping strategy, but is \
	not a char array field.
not-serialized: Field "{0}" declares a blob mapping strategy, but the \
	field''s value is not serialized.  Set the field''s "serialized" attribute \
	to true.
not-relation: "{0}" declares a relation mapping strategy, but is not a \
	direct, non-embedded relation to another persistence-capable object.
not-elem-relation: "{0}" declares a to-many relation strategy, but its \
	elements are not direct, non-embedded relations to another mapped \
	persistence-capable object.
not-inv-relation: Field "{0}" declares "{1}" as its mapped-by field, but this \
	field is not a direct relation.
not-inv-relation-coll: Field "{0}" declares "{1}" as its mapped-by field, but \
	this field is not a collection of inverse relations.
not-coll: Field "{0}" declares a collection mapping strategy, but is not a \
	collection or array type.
coll-owner:  Inefficient mapping: You have declared that field "{0}" is mapped \
	by collection "{1}".  The mapping would be much more efficient if instead \
	you map "{0}" and declare that "{1}" is mapped by it.
class-crit-owner: Field "{0}" declares that it uses class criteria for joins, \
	and this field is not owned by an inverse field.  As a result, it is \
	impossible to correctly null the inverse foreign keys when the field is \
	deleted.  OpenJPA may leave orphan key values in the database if you do \
    not provide an owning inverse relation using the "mapped-by" attribute.
not-map: Field "{0}" declares a Map mapping strategy, but it is not a Map type.
mapped-by-key: Map field "{0}" is attempting to use a map table, but its key \
	is mapped by another field.  Use an inverse key or join table mapping.
not-mapped-by-key: Map field "{0}" is attempting to use an inverse key or join \
	table mapping, but its key is not mapped by another field.  Use a map \
	table mapping.
no-handler: Field "{0}" declares a handler-based mapping strategy, but no \
	value handler is installed.
auto-assign-handler: Attempt to use an auto-assigned column value in a handler \
	with multiple columns.  To use an auto-assigned column value with field \
	"{0}", you will have to write a custom field mapping that implements the \
	org.apache.openjpa.jdbc.meta.Joinable interface.
load-subs: Loading subclasses from discriminator column of "{0}".
no-class-name: The discriminator column "{1}" for type "{1}" contains a null \
	or empty value.
cant-init-subs: The discriminator for type "{0}" cannot compute the list of \
	its subclasses on its own.  You should either use a discriminator strategy \
	that has this ability (such as the class-name strategy), include the set \
	of persistent classes in the "openjpa.MetaDataFactory" property so that \
    OpenJPA can discover all persistent classes at startup, or make sure that \
    all subclasses of this type have had their class instantiated in the JVM \
	before performing any persistent operations on this class or its \
	subclasses.  If this class does not have any subclasses, consider making \
	the class final or changing its discriminator strategy to "final".
no-discrim-value: Type "{0}" uses the value-map discriminator strategy, but \
	does not declare a discriminator value.
dup-discrim-value: Discriminator value "{0}" is used for two different \
	classes in the same inheritance tree: "{1}", "{2}"
outer-join-support: The subclass-join class indicator mapped to "{0}" requires \
	outer joins to function.  Your database dictionary is configured to use \
	"traditional" join syntax, which does not support outer joins.  To \
	use SQL 92 joins instead, set the following property:\n\
	openjpa.jdbc.DBDictionary: JoinSyntax=sql92
unknown-discrim-value: Could not map discriminator value "{0}" to any \
	known subclasses of the requested class "{1}" (known discriminator \
	values: {2}).
bad-unmapped-rel: "{0}" cannot be mapped without stringifying the oid of \
	the related object to a string column.  The related type is unmapped and \
	its "{1}" primary key field does not use a simple mapping.
unmapped-datastore-value: Instances of type "{0}" are not valid query \
	parameters because the type is not mapped.
cant-set-value: Field "{1}" of "{0}" can not be set to "{2}" value.
multi-column-version-unsupported:You have specified more than one column for \
	version data, but the "{1}" version strategy does not support multi-column \
	versioning.
not-enum-field: Field "{0}" is expected to be a enum but actually is of type "{1}".
