| # 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. |
| |
| cant-convert-result: There is no conversion between query projection type \ |
| "{0}" and result type "{1}". |
| unloaded-detached: Attempt to access an unloaded field of detached instance \ |
| "{0}". |
| meta-unknownid: Cannot manipulate identity of type "{0}": it''s identity type \ |
| is unknown. |
| new-abstract: Cannot create an instance of "{0}": abstract classes are not \ |
| yet supported. |
| bad-new-query: Attempt to construct a query from an extent or class. You must \ |
| pass a (possibly null) query string or template to the query factory \ |
| method when creating the query. |
| update-restrict: Detected attempt to modify field "{0}" with value strategy \ |
| "restrict". |
| reentrant-flush: Detected reentrant flush. Make sure your flush-time instance \ |
| callback methods or event listeners do not invoke any operations that \ |
| require the in-progress flush to complete. |
| rolled-back: The transaction has been rolled back. See the nested exceptions \ |
| for details on the errors that occurred. |
| bad-lock-level: This lock manager does not recognize lock level "{0}". |
| pessimistic-mutate: You are attempting to directly mutate a persistent second \ |
| class object (such as a collection or map field) that you obtained before \ |
| the transaction began. After beginning a datastore transaction, you \ |
| must re-obtain any references to mutable second class objects from the \ |
| owning persistent object. Detected attempt to mutate value of field "{0}" \ |
| in instance "{1}". This instance may not be locked correctly. |
| not-derefed: Encountered unknown dependent instance "{0}". This error is \ |
| often caused by either removing a dependent instance from one dependent \ |
| field, but not other dependent fields that reference it, or by removing a \ |
| dependent instance from its owning field, flushing \ |
| (causing the unreferenced dependent instance to be deleted), and then \ |
| trying to assign the deleted instance to another field before commit. \ |
| The instance cannot be un-deleted, resulting in an error. Make sure not \ |
| to leave dangling dependent references to objects, and to reassign \ |
| dependent objects before flush so that OpenJPA does not think they are \ |
| unreferenced and therefore safe to delete. |
| init-null-pc: Attempt to initialize a state manager with a null \ |
| persistence-capable instance for type "{0}". This is often caused by \ |
| attempting to load an instance of an abstract class, or \ |
| neglecting to use a class indicator when the base persistence-capable \ |
| class in an inheritance tree is abstract. |
| init-sm-pc: Attempt to initialize a state manager with an instance that is \ |
| already managed ("{0}"). You might be trying to persist this instance \ |
| in two threads at the same time. |
| bad-ds-oid: The type "{0}" declares datastore identity but the value \ |
| passed to lookup of type "{1}" is not a OpenJPA id instance. |
| null-oids: Some of the object ids passed to getObjectsById were null. |
| marked-rollback: The transaction cannot be committed, because it was already \ |
| marked for rollback only. The transaction will be rolled back instead. \ |
| The cause of the rollback-only status is reported in the embedded stack. |
| refresh-flushed: You cannot refresh an instance that has been flushed to the \ |
| data store. |
| pc-loader-different: Attempt to cast instance "{0}" to PersistenceCapable failed. \ |
| The object implemented org.apache.openjpa.enhance.PersistenceCapable, \ |
| but the instance of that interface was loaded by two different ClassLoaders: \ |
| "{1}" and "{2}". |
| pc-cast: Attempt to cast instance "{0}" to PersistenceCapable failed. Ensure \ |
| that it has been enhanced. |
| del-instance: The instance of type "{0}" with oid "{1}" no longer exists in \ |
| the data store. This may mean that you deleted the instance in a separate \ |
| transaction, but this context still has a cached version. |
| no-broker-class: The specified type "{0}" could not be loaded. Please ensure \ |
| that the class exists in the project class path. |
| bad-embed: Attempt to set an embedded value for unembeddable field "{0}". \ |
| Please report this error to OpenJPA support. |
| embed-ref: You are attempting to access an embedded object reference \ |
| that was obtained before the last transaction status change. After \ |
| transactions begin and end, all references to embedded objects become \ |
| invalid; you have to re-acquire the reference from the owning persistent \ |
| object. |
| deleted: Operation attempted on a deleted instance. |
| dirty: Illegal operation attempted on a dirty instance: dirty objects cannot \ |
| be evicted or made transient or non-transactional. |
| nested-exceps: This operation failed for some instances. See the nested \ |
| exceptions array for details. |
| new: Illegal operation attempted on a newly persisted instance: new objects \ |
| cannot be evicted or made transient or non-transactional. |
| transient: Illegal operation attempted on a transient instance. |
| not-active: Can only perform operation while a transaction is active. |
| trans-active: The "{0}" transaction property cannot be set during an \ |
| active transaction. |
| active: This operation cannot be performed while a Transaction is active. |
| closed: The context has been closed. The stack trace at which the \ |
| context was closed is held in the embedded exception. |
| closed-notrace: The context has been closed. The stack trace at which the \ |
| context was closed is available if Runtime=TRACE logging is enabled. |
| closed-factory: The factory has been closed. The stack trace at \ |
| which the factory was closed is held in the embedded exception. |
| closed-factory-notrace: The factory has been closed. The stack trace at \ |
| which the factory was closed is available if Runtime=TRACE logging is \ |
| enabled. |
| non-trans-read: To perform reads on persistent data outside of a transaction, \ |
| the "NontransactionalRead" property must be set on the Transaction. |
| non-trans-write: To perform writes on persistent data outside of a \ |
| transaction, the "NontransactionalWrite" property must be set to true. |
| write-operation: To perform this operation, it must be written within a transaction, \ |
| or your settings must allow nontransactional writes and must not detach \ |
| all nontransactional reads. |
| not-managed: The given instance "{0}" is not managed by this context. |
| trans-not-managed: This broker is not configured to use managed transactions. |
| bad-detached-op: You cannot perform operation {0} on detached object "{1}". \ |
| This operation only applies to managed objects. |
| persist-detached: Attempt to persist detached object "{0}". If this is a new \ |
| instance, make sure any version and/or auto-generated primary key fields are \ |
| null/default when persisting. |
| null-value: The field "{0}" of instance "{1}" contained a null value; \ |
| the metadata for this field specifies that nulls are illegal. |
| change-identity: Attempt to change a primary key field of an instance that \ |
| already has a final object id. Only new, unflushed instances whose id you \ |
| have not retrieved can have their primary keys changed. |
| managed-oid: You cannot assign managed object "{0}" to the primary key field \ |
| of "{1}". Embedded primary key values must be transient objects. |
| changed-oid: You have modified the object id field of "{2}". Its old value \ |
| was "{0}", and its new value is "{1}". Object id fields are immutable \ |
| once the object id of the instance has been assigned. |
| cache-exists: An object of type "{0}" with oid "{1}" already exists in this \ |
| context; another cannot be persisted. |
| null-trans: Attempt to commit a null javax.transaction.Transaction. Some \ |
| application servers set the transaction to null if a rollback occurs. |
| end-trans-error: An exception occurred while ending the transaction. This \ |
| exception will be re-thrown. |
| not-bound: The file named "{0}" could not be found. |
| naming-exception: A NamingException was thrown while obtaining the \ |
| factory at "{0}" from JNDI. |
| attach-deleted: The object "{0}" with id "{1}" has been deleted and \ |
| cannot be attached. |
| not-detachable: The class "{0}" does not declare the "detachable" metadata \ |
| extension, so cannot be detached. |
| not-copyable: Attempt to copy field "{0}" failed. The field is \ |
| not copyable. This can occur with custom SCO types. Only standard or \ |
| immutable SCO types can be attached and detached. |
| no-detach-object-id: Cannot access the detached object id of class "{0}". \ |
| Ensure that the class has the "detachable" metadata extension, and \ |
| the the class has been re-enhanced. |
| attach-version-del: Attempted to attach deleted instance type "{0}" with oid \ |
| "{1}". If the instance is new, the version field should be left to its \ |
| default value. |
| attach-wrongclass: Attempted to attach instance "{0}" of type "{1}", but this \ |
| instance is already in the datastore as type "{2}". |
| sjvm-acquired-lock: Acquired an exclusive lock "{0}" on oid "{1}". |
| sjvm-released-lock: Released lock "{0}". |
| conn-not-supported: This data store cannot return connections. |
| incremental-flush-not-supported: This data store does not support incremental \ |
| flushing. If you got this error while performing a query, make sure that \ |
| you have not set the FlushBeforeQueries option to true, either by \ |
| setting that option in your configuration file, or by programmatically \ |
| setting the current FetchConfiguration''s FlushBeforeQueries property \ |
| to QueryFlushModes.FLUSH_TRUE. |
| nontrans-read-not-supported: This data store does not support nontransactional \ |
| reads. Set the NontransactionalRead property to false. |
| optimistic-not-supported: This datastore does not support optimistic \ |
| transactions. Set the Optimistic property to false. |
| restore-unset: The RestoreValues option is off, so initial values are \ |
| not available. Turn on RestoreValues to be able to obtain initial \ |
| values. |
| mutable-restore-unset: The RestoreValues option is not set to "all", \ |
| initial values of mutable fields are not available. Set RestoreValues to \ |
| "all" in your properties to be able to obtain initial mutable values. |
| initial-unloaded: OpenJPA cannot provide the initial value for field "{0}" \ |
| because the field was never loaded before being changed. |
| dup-oid-assign: Attempt to assign id "{0}" to new instance "{1}" failed; \ |
| there is already an object in the L1 cache with this id. \ |
| You must delete this object (in a previous transaction or the current one) \ |
| before reusing its id. This error can also occur when a horizontally \ |
| or vertically mapped classes uses auto-increment application identity and \ |
| does not use a hierarchy of application identity classes. |
| dup-load: Cannot load object with id "{0}". Instance "{1}" with the same id \ |
| already exists in the L1 cache. This can occur when you \ |
| assign an existing id to a new instance, and before flushing attempt to \ |
| load the existing instance for that id. |
| bad-id-value: The given value "{0}" cannot be converted into an identity \ |
| for "{2}". The value is the wrong type ({1}). |
| factory-init: Starting OpenJPA {0} |
| factory-properties: Properties: {0} |
| inverse-consistency: An inverse inconsistency in the object model was \ |
| detected while flushing the field "{0}" of the instance with id "{1}" \ |
| in context "{2}". |
| no-brokerfactory: You did not name the factory class with the required \ |
| property openjpa.BrokerFactory. Normally this property defaults \ |
| appropriately; have you forgotten to include all the OpenJPA jars in your \ |
| classpath? |
| brokerfactory-excep: There was an error when invoking the static \ |
| getInstance method on the named factory class "{0}". See the \ |
| nested exception for details. |
| new-brokerfactory-excep: There was an error when invoking the static \ |
| newInstance method on the named factory class "{0}". See the \ |
| nested exception for details. |
| bad-brokerfactory: Could not invoke the static getInstance method on the \ |
| named factory class "{0}". |
| bad-new-brokerfactory: Could not invoke the static newInstance method on the \ |
| named factory class "{0}". |
| bad-brokerfactory-class: The named BrokerFactory "{0}" is not valid. |
| instantiate-abstract: Cannot instantiate abstract class of type "{0}" with \ |
| object id "{1}"; this may indicate that the inheritance discriminator \ |
| for the class is not configured correctly. |
| nontrans-proxied: You cannot make a property access object created with "new" \ |
| nontransactional. |
| no-field: Field "{0}" is not declared in "{1}", or is not managed. |
| no-field-index: "{0}" is not the index of any managed field in "{1}". |
| cant-cascade-persist: Encountered unmanaged object in persistent field \ |
| "{0}" during flush. However, this field does not \ |
| allow cascade persist. Set the cascade attribute for this field to \ |
| CascadeType.PERSIST or CascadeType.ALL (JPA annotations) or \ |
| "persist" or "all" (JPA orm.xml), or enable cascade-persist globally, \ |
| or manually persist the related field value prior to flushing. \ |
| You cannot flush unmanaged objects or graphs that have persistent \ |
| associations to unmanaged objects. |
| cant-cascade-attach: Encountered new object in persistent field \ |
| "{0}" during attach. However, this field does not \ |
| allow cascade attach. Set the cascade attribute for this field to \ |
| CascadeType.MERGE or CascadeType.ALL (JPA annotations) or \ |
| "merge" or "all" (JPA orm.xml). \ |
| You cannot attach a reference to a new object without cascading. |
| ref-to-deleted: Encountered deleted object "{0}" in persistent field \ |
| "{1}" of managed object "{2}" during flush. |
| no-version-field: Encountered object "{0}" without a version field during \ |
| attach. In order to attach an object, it must either be enhanced or must \ |
| have a version field. |
| inmem-agg-proj-var: Queries with aggregates or projections using variables \ |
| currently cannot be executed in-memory. Either set IgnoreCache to true, \ |
| set the openjpa.FlushBeforeQueries property to true, or execute the query \ |
| before changing any instances in the transaction. The offending query was \ |
| on type "{0}" with filter "{1}". |
| merged-order-with-result: This query on candidate type "{0}" with filter "{1}" \ |
| involves combining the results of multiple queries in memory. \ |
| You have chosen to order the results on "{2}", but you have not selected \ |
| this data in your setResult() clause. Please include this ordering data \ |
| in setResult() so that OpenJPA can extract it for in-memory ordering. |
| bad-grouping: Your query on type "{0}" with filter "{1}" is invalid. Your \ |
| select and having clauses must only include aggregates or values that also \ |
| appear in your grouping clause. |
| query-nosupport: The "{0}" query type does not support this operation. |
| query-unmapped: You cannot query unmapped type "{0}". |
| range-too-big: The range of the query is too big. Start index: "{0}", end \ |
| index: "{1}". The range must be less than Integer.MAX_VALUE. |
| invalid-range: The query range from {0} to {1} is not valid. |
| no-impls: Unable to execute a query on type "{0}". This class or interface \ |
| is not mapped, and does not have any mapped implementors. |
| bad-param-name: The parameter name or position "{0}" passed to \ |
| execute() is not valid. All map keys must be a declared parameter \ |
| name or a number matching the parameter position. Native queries only \ |
| allow the use of positional parameters. |
| force-in-mem: This query on type "{0}" must load the entire candidate class \ |
| extent and evaluate the query in-memory. This may be very slow. The \ |
| query must be executed in memory because OpenJPA is configured with \ |
| IgnoreCache=false and FlushBeforeQueries=false and \ |
| there are dirty instances that may affect the query''s outcome in the \ |
| cache. |
| cant-exec-inmem: Queries of this type ("{0}") cannot be executed in-memory. \ |
| Either set IgnoreCache to true, set the openjpa.FlushBeforeQueries \ |
| property to true, or execute the query before changing any instances in \ |
| the transaction. |
| executing-query: Executing query: {0} |
| executing-query-with-params: Executing query: [{0}] with parameters: {1} |
| not-unique: The query on candidate type "{0}" with filter "{1}" was \ |
| configured to have a unique result, but more than one instance matched \ |
| the query. |
| no-result: The query on candidate type "{0}" with filter "{1}" was \ |
| configured to have a unique result, but no instance matched \ |
| the query. |
| serialized: Queries that have been serialized do not support this operation. |
| read-only: Attempt to modify a read-only query object. |
| no-class: A candidate Class must be specified before executing a query. |
| no-modify-resultclass: A query that declares a result class cannot be used \ |
| to perform bulk updates. |
| no-modify-unique: A query that declares unique results cannot be used \ |
| to perform bulk updates. |
| no-modify-range: A query that declares a result range cannot be used \ |
| to perform bulk updates. |
| unbound-param: Cannot execute query; the declared parameter "{0}" was \ |
| not given a value. |
| unbound-params: Cannot execute query; some declared parameters were not given \ |
| values. You must supply a value for each of the following parameters, \ |
| in the given order: {0} |
| extra-params: More parameters were passed to execute() than were declared: \ |
| {1} parameters were specified for query execution, but only {0} \ |
| parameters were declared in the query. |
| null-primitive-param: Parameter "{0}" was declared with a primitive type, but \ |
| has been given a null value. |
| merged-aggregate: This query on candidate type "{0}" with filter "{1}" \ |
| involves combining the results of multiple sub-queries. However, because \ |
| this query is for aggregate data, OpenJPA cannot combine the sub-query \ |
| aggregates into correct final values. |
| bad-dec: The {1} declaration "{0}" is \ |
| not valid. Variables and imports must be delimited with ";". Parameters \ |
| and orderings must be delimited with ",". Imports require the "import" \ |
| keyword, and orderings require the "ascending" or "descending" keyword. |
| mod-bigdecimal: You cannot use the modulo operator (%) on numbers of type \ |
| BigDecimal. |
| cant-convert: Cannot convert object "{0}" of type "{1}" into an instance of \ |
| "{2}". |
| bad-method-class: You set the method name of this openjpa.MethodQL query to \ |
| "{1}", but class "{0}" is not a valid class name. Make sure to fully \ |
| qualify the class name or to import its package into this query if the \ |
| class is not in the query candidate class'' package. |
| method-not-static: Method "{0}" named in the MethodQL query must be static. |
| method-return-type-invalid: Method "{0}" named in the MethodQL query must \ |
| have a return type that is assignable from ResultObjectProvider. Return \ |
| type is: {1}. |
| no-method: You must set the query filter to the name of the method to execute \ |
| for this MethodQL query instance. |
| method-error: There was an error invoking method "{0}" with arguments "{1}". |
| bad-param-type: The type "{0}" as used in the parameter declarations \ |
| could not be found in the imports. |
| cant-set: Result type "{0}" does not have any public fields or setter methods \ |
| for the projection or aggregate result element "{1}", nor does it have a \ |
| generic put(Object,Object) method that can be used, nor does it have a \ |
| public constructor that takes the types {2}. |
| pack-err: There was an error packing the projection and/or aggregate results \ |
| of the query into result type "{0}". See the nested Throwable exception \ |
| for details. |
| pack-instantiation-err: There was an error creating an instance of type "{0}" \ |
| when packing the projection and/or aggregate results of the query. Ensure \ |
| that you have defined a public no-args constructor in "{0}". |
| bad-inmem-method: Method "{0}(StoreContext, ClassMetaData, boolean, Object, \ |
| Map, FetchConfiguration)" is not declared in type "{1}". \ |
| Check the method name supplied in your MethodQL query filter. \ |
| OpenJPA is attempting to execute this query in-memory; if you implemented \ |
| the datastore method instead (a method with the same signature but without \ |
| the Object argument) and want this query to execute in the datastore, \ |
| either create the query before modifying objects in the current transaction, \ |
| set IgnoreCache to true, or set the openjpa.FlushBeforeQueries property to \ |
| true. |
| bad-datastore-method: Method "{0}(StoreContext, ClassMetaData, boolean, Map, \ |
| FetchConfiguration)" is not declared in type "{1}". Check \ |
| the method name supplied in your MethodQL query filter. OpenJPA is \ |
| attempting to execute this query against the datastore; if you implemented \ |
| the in-memory method instead (a method with the same signature but with an \ |
| Object argument) and want this query to execute in-memory, supply a \ |
| Collection of candidates to filter. |
| only-update-constants: Bulk update queries when executed in memory \ |
| may only update to constant values. |
| only-range-constants: Range values must be numeric constants. Illegal query: \ |
| {0} |
| no-savepoint-copy: Unable to copy field "{0}" for savepoint. |
| savepoint-exists: A savepoint with the name "{0}" already exists. \ |
| Each savepoint name must be unique. |
| no-lastsavepoint: Cannot rollback/release last savepoint as no savepoint \ |
| has been set. |
| no-savepoint: You have not set a savepoint with the name "{0}" |
| savepoint-init: This savepoint has already been initialized. |
| savepoint-flush-not-supported: The configured SavepointManager does not \ |
| support incremental flushing when a savepoint has been set. You must \ |
| release your savepoints before flushing. |
| callback-err: Errors occurred processing listener callbacks. See the nested \ |
| exceptions for details. |
| bad-agg-listener-hint: Query hint value "{0}" ({1}) cannot be converted into \ |
| an aggregate listener. |
| bad-filter-listener-hint: Query hint value "{0}" ({1}) cannot be converted \ |
| into a filter listener. |
| bad-setter-hint-arg: In query hint "{0}", cannot convert hint value "{1}" to \ |
| type "{2}". |
| detach-val-mismatch: The instance "{0}" is managed by another context and \ |
| cannot be inspected for field values. |
| detach-val-badsm: The instance "{0}" has an unknown state manager which \ |
| prevents field inspection. |
| null-oid: Cannot perform find using null object id. |
| illegal-op-in-prestore: This operation is illegal when called during \ |
| transaction completion. |
| no-expressions: The query cannot be executed because it has no \ |
| valid expressions. |
| null-fg: Attempt to add null/empty fetch group name to fetch configuration. |
| null-field: Attempt to add null/empty field name to fetch configuration. |
| container-projection: Query projections cannot include array, collection, or \ |
| map fields. Invalid query: "{0}" |
| existing-value-override-excep: The generated value processing detected an \ |
| existing value assigned to this field: {0}. This existing value was either \ |
| provided via an initializer or by calling the setter method. You either need \ |
| to remove the @GeneratedValue annotation or modify the code to remove the \ |
| initializer processing. |
| invalid-tran-status: The transaction was not in a valid state ({0}) to \ |
| accept the "{1}" method invocation. Processing will continue. |
| multi-threaded-access: Multiple concurrent threads attempted to access a \ |
| single broker. By default brokers are not thread safe; if you require \ |
| and/or intend a broker to be accessed by more than one thread, set the \ |
| openjpa.Multithreaded property to true to override the default behavior. |
| no-saved-fields: No state snapshot is available for instance of type "{0}", \ |
| but this instance uses state-comparison for dirty detection. |
| cant-serialize-flushed-broker: Serialization not allowed once a broker has \ |
| been flushed. |
| cant-serialize-pessimistic-broker: Serialization not allowed for brokers with \ |
| an active datastore (pessimistic) transaction. |
| cant-serialize-connected-broker: Serialization not allowed for brokers with \ |
| an active connection to the database. |
| no-interface-metadata: No metadata was found for managed interface {0}. |
| fetch-configuration-stack-empty: Fetch configuration stack is empty. |
| gap-query-param: Parameter {1} for query "{0}" exceeds the number of {2} \ |
| bound parameters with following values "{3}". This can happen if you have \ |
| declared but missed to bind values for one or more parameters. |
| query-execution-error: Failed to execute query "{0}". Check the query syntax \ |
| for correctness. See nested exception for details. |
| prepared-query-cache: Adding query "{0}" to prepared query cache. The target \ |
| database query is "{1}". |
| prepared-query-not-cachable: Query "{0}" can not be cached. |
| prepared-query-invalidate: Prepared Query "{0}" is invalidated |
| prepared-query-uncache-strong: Query "{0}" is marked permanently not to be \ |
| cached. |
| prepared-query-uncache-weak: Query "{0}" is marked not to be cached because it \ |
| matched exclusion pattern "{1}". This query can be cached if the exclusion \ |
| pattern is removed later. |
| prepared-query-add-pattern: Added exclusion pattern "{0}" which has removed \ |
| following {1} prepared queries from the cache: "{2}" |
| prepared-query-remove-pattern: Removed exclusion pattern "{0}" which has made \ |
| following {1} queries again possible to be cached: "{2}" |