| # 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. |
| cache-hit: SQL Cache hit with key: {0} in {1} |
| cache-missed: SQL Cache missed with key: {0} in {1} |
| cant-set-value: Field "{1}" of "{0}" can not be set to "{2}" value. |