openjpa-jdbc/src/main/resources/org/apache/openjpa/jdbc/meta/localizer.properties

# 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.  

resolve-mapping: Resolving mapping for "{0}".
init-mapping: Initializing mapping for "{0}".
strategy: "{0}" has mapping strategy "{1}".
field-strategy: \t"{0}" has mapping strategy "{1}".
no-equiv-col: Cannot use "{0}" as the mapped-by value for a field in "{1}".  \
	There is no column "{2}" in this subclass'' table.
no-equiv-field: Cannot use "{0}" as the mapped-by value for a field in "{1}".  \
	There is no target-field "{2}" for column "{3}" in this subclass.
bad-equiv-field: Cannot use "{0}" as the mapped-by value for a field in "{1}". \
	The target-field "{2}" for column "{3}" is mapped to multiple columns.
no-mapping: No mapping information found for type "{0}".
bad-mapped-by: Collection field "{0}" declares that it is mapped by "{1}", but \
	this is not a valid inverse relation.
no-targetfield: Some of the columns on "{0}" are missing target field \
	declarations.
bad-targetfield: "{0}" has a column with target field "{1}", but that is not a \
	primary key field of the related class.
no-joinable: You cannot join on column "{0}".  It is not managed by a mapping \
	that supports joins.
join-required: Missing table name for field "{0}".  This field cannot reside \
	in the owning class table.
bad-discrim-value: The declared discriminator value "{1}" for type "{0}" \
	cannot be parsed as a number, though it starts with a digit.
unexpected-cols: You have supplied columns for "{0}", but this mapping cannot \
	have columns in this context.
unexpected-index: "{0}" is marked as indexed, but OpenJPA does not support \
	an index on this mapping in this context.
unexpected-unique: "{0}" is marked as having a unique constraint, but OpenJPA \
	does not support a constraint on this mapping in this context.
unexpected-fk: "{0}" is marked as having a foreign key, but OpenJPA does not \
	support a foreign key on this mapping in this context.
unexpected-join: "{0}" has columns with targets, but OpenJPA does not support any \
	joins on this mapping in this context.
unexpected-strategy: "{0}" has an invalid mapping strategy in this context. \
	Expected "{1}" but found "{2}".
no-table: No table was given for persistent type "{0}".
bad-table: Table "{0}" given for "{1}" does not exist.
generic-num-cols: For "{0}", expected {1} column(s), but found {2}.
generic-no-col-name: No column name was given for "{0}".
generic-bad-col-name: "{0}" declares column "{1}", but this column does not \
	exist in table "{2}".
generic-incompat-col: "{0}" declares a column "{1}" whose JDBC type is not \
	compatible with the expected type "{2}".
generic-bad-col: "{0}" declares a column that is not compatible with the \
	expected type "{1}".  Column details:\n{2}
datastoreid-num-cols: For type "{0}", expected {1} datastore identity \
	column(s), but found {2}.
datastoreid-no-col-name: No datastore identity column name was given for "{0}".
datastoreid-bad-col-name: Type "{0}" declares datastore identity column "{1}", \
	but this column does not exist in table "{2}".
datastoreid-incompat-col: Type "{0}" declares a datastore identity column \
	"{1}" whose JDBC type is not compatible with the expected type "{2}".
datastoreid-bad-col: Type "{0}" declares a datastore identity column that is \
	not compatible with the expected type "{1}".  Column details:\n{2}
nondfg-field-orderable: Cannot order "{0}" on "{1}", because that field is not \
	in the default fetch group.  You can only order on fields that will be \
	selected when the related object is loaded.
order-conflict: Field "{0}" declares both a synthetic ordering column and \
	order-by values.  You cannot use both.
order-no-col-name: No order column name was given for "{0}".
order-bad-col-name: "{0}" declares order column "{1}", but this column does \
	not exist in table "{2}".
order-incompat-col: "{0}" declares an order column "{1}" whose JDBC type is \
	not compatible with the expected type "{2}".
order-bad-col: "{0}" declares an order column column that is not compatible \
	with the expected type "{1}".  Column details:\n{2}
null-ind-no-col-name: No null indicator column name was given for "{0}".
null-ind-bad-col-name: "{0}" declares null indicator column "{1}", but this \
	column does not exist in table "{2}".
null-ind-incompat-col: "{0}" declares a null indicator column "{1}" whose \
	JDBC type is not compatible with the expected type "{2}".
null-ind-bad-col: "{0}" declares a null indicator column column that is not \
	compatible with the expected type "{1}".  Column details:\n{2}
generic-no-index-cols: "{0}" declares an index, but has no columns.
generic-index-exists: "{0}" marks its columns as explicitly not indexed, but \
	an index exists.
generic-index-not-unique: "{0}" marks its columns as having a unique index, \
	but the existing index on those columns is not unique.
generic-no-unique-cols: "{0}" declares a unique constraint, but has no columns.
generic-unique-exists: "{0}" marks its columns as explicitly not unique, but \
	a unique constraint exists.
generic-unique-support: "{0}" marks its columns as having a unique constraint, \
	but your database does not support unique constraints.  Include \
	"SupportsUniqueConstraints=true" in the openjpa.jdbc.DBDictionary \
	configuration property to override this default.
generic-defer-unique: "{0}" marks its columns as having a deferred unique \
	constraint, but the existing constraint on these columns is not deferred. \
	OpenJPA cannot change the deferrability of a constraint.
generic-create-defer-unique: "{0}" marks its columns as having a deferred \
	unique constraint, but the database dictionary "{1}" reports that it does \
	not support deferred constraints.  Creating an undeferred constraint.
generic-no-fk-cols: "{0}" declares a foreign key, but has no columns.
generic-no-fkcol-name: "{0}" does not supply a name for at least one declared \
	column.
generic-bad-fkconst: "{0}" declares invalid constant value target "{1}" for \
	column with name "{2}".
generic-bad-fktarget-inverse: "{0}" declares a target for column "{1}" in \
	table "{3}", but all targets must be in table "{2}".
generic-bad-fk-inverse: "{0}" declares a column in table "{1}", but all \
	columns must be in table "{2}".
generic-bad-fk-self-inverse: "{0}" declares an inverse self-join on table \
	"{1}", but this mapping does not allow inverse joins.  If you did not \
	intend to make this an inverse join, take the table name out of the \
	column names for this mapping.
generic-no-fkcol-name-adapt: "{0}" does not supply a name for at least one \
	declared column.  Since this mapping can involve multiple columns or uses \
	constant joins, each column must give either its name or a non-constant \
	target.
generic-no-fkcol-target-adapt: "{0}" does not supply a target for column \
	"{1}".  Since this mapping can involve multiple columns and the a target \
	column with the same name doesn''t exist, you must give a target explicitly.
generic-bad-fktarget: "{0}" defines a target of "{1}" for column "{2}", but \
	that target does not exist in table "{3}".
generic-bad-fktargetcls: "{0}" defines target field "{1}" for column \
	"{2}", but OpenJPA cannot determine the owning class for that field.
generic-bad-fktargetfield: "{0}" defines target field "{1}" for column \
	"{2}", but that field does not exist in type "{3}".
generic-fktargetfield-cols: "{0}" defines target field "{1}" for column \
	"{2}", but that field is either unmapped or has multiple columns.
generic-mult-fk-tables: "{0}" uses columns from multiple different tables: \
	"{1}", "{2}"
generic-fk-exists: "{0}" marks its columns as explicitly not having a foreign \
	key delete action, but a database foreign key exists on these columns.
generic-defer-fk: "{0}" marks its columns as having a deferred foreign key, \
	but the existing constraint on these columns is not deferred. OpenJPA cannot \
	change the deferrability of a constraint.
generic-create-defer-fk: "{0}" marks its columns as having a deferred foreign \
	key, but the database dictionary "{1}" reports that it does not support \
	deferred constraints.  Creating an undeferred constraint.
generic-unsupported-fk-action: "{0}" uses an unsupported foreign key delete or \
	update action on its columns.  Reverting to a logical foreign key.
generic-const-join: "{0}" attempts to join a constant value to another constant \
	value.
superclass-no-fk-cols: Type "{0}" is missing information on how to join to \
	its superclass.
superclass-no-fkcol-name: Type "{0}" does not supply a name for at least one \
	declared superclass join column.
superclass-bad-fkconst: Type "{0}" declares invalid constant value target \
	"{1}" for the column with name "{2}" in its superclass join.
superclass-bad-fktarget-inverse: Type "{0}" declares superclass join column \
	"{1}" with a target in table "{3}", but all targets must be in table "{2}".
superclass-bad-fk-inverse: Type "{0}" declares a superclass join in table \
	"{1}", but all columns must be in table "{2}".
superclass-no-fkcol-name-adapt: Type "{0}" does not supply a name for at \
	least one declared column in its superclass join.  Since this join can \
	involve multiple columns, each column must give either its name or its \
	target.
superclass-no-fkcol-target-adapt: Type "{0}" does not supply a target for \
	column "{1}" in its superclass join.  Since this mapping can involve \
	multiple columns and the a target column with the same name doesn''t \
	exist, you must give a target explicitly.
superclass-bad-fktarget: Type "{0}" defines a target of "{1}" for superclass \
	join column "{2}", but that target does not exist in table "{3}".
superclass-bad-fktargetcls: "{0}" defines target field "{1}" for superclass \
	join column "{2}", but OpenJPA cannot determine the owning class for that \
	field.
superclass-bad-fktargetfield: Type "{0}" defines target field of "{1}" for \
	superclass join column "{2}", but that field does not exist in type "{3}".
superclass-fktargetfield-cols: Type "{0}" defines target field "{1}" for \
	superclass join column "{2}", but that field is either unmapped or has \
	multiple columns.
superclass-mult-fk-tables: The superclass join on type "{0}" uses columns from \
	multiple different tables: "{1}", "{2}"
superclass-fk-exists: Type "{0}" marks its superclass join columns as \
	explicitly not having a foreign key delete action, but a database foreign \
	key exists on these columns.
superclass-defer-fk: Type "{0}" marks its superclass join columns as having a \
	deferred foreign key, but the existing constraint on these columns is not \
	deferred. OpenJPA cannot change the deferrability of a constraint.
superclass-create-defer-fk: Type "{0}" marks its superclass join columns as \
	having a deferred foreign key, but the database dictionary "{1}" reports \
	that it does not support deferred constraints.  Creating an undeferred \
	constraint.
superclass-unsupported-fk-action: Type "{0}" uses an unsupported foreign key \
	delete or update action on its superclass join columns.  Reverting to a \
	logical foreign key.
superclass-const-join: "{0}" attempts to join a constant value to another \
	constant value.
join-no-index-cols: "{0}" declares a join index, but has no join columns.
join-index-exists: "{0}" marks its join columns as explicitly not indexed, but \
	an index exists.
join-index-not-unique: "{0}" marks its join columns as having a unique index, \
	but the existing index on those columns is not unique.
join-no-unique-cols: "{0}" declares a unique join constraint, but has no \
	join columns.
join-unique-exists: "{0}" marks its join columns as explicitly not unique, but \
	a unique constraint exists.
join-unique-support: "{0}" marks its join columns as having a unique \
	constraint, but your database does not support unique constraints.  \
	Include "SupportsUniqueConstraints=true" in the openjpa.jdbc.DBDictionary \
	configuration property to override this default.
join-defer-unique: "{0}" marks its join columns as having a deferred unique \
	constraint, but the existing constraint on these columns is not deferred. \
	OpenJPA cannot change the deferrability of a constraint.
join-create-defer-unique: "{0}" marks its join columns as having a deferred \
	unique constraint, but the database dictionary "{1}" reports that it does \
	not support deferred constraints.  Creating an undeferred constraint.
join-no-fk-cols: "{0}" declares a join foreign key, but has no join columns.
join-no-fkcol-name: "{0}" does not supply a name for at least one declared \
	join column.
join-bad-fkconst: "{0}" declares invalid constant value target "{1}" for \
	join column with name "{2}".
join-bad-col-name: "{0}" declares column "{1}", but this column does not \
	exist in table "{2}".
join-bad-fktarget-inverse: "{0}" declares a target for join column "{1}" in \
	table "{3}", but all join targets must be in table "{2}".
join-bad-fk-inverse: "{0}" declares a join column in table "{1}", but all \
	join columns must be in table "{2}".
join-bad-fk-self-inverse: "{0}" declares an inverse self-join on table \
	"{1}", but this mapping does not allow inverse joins.  If you did not \
	intend to make this an inverse join, take the table name out of the \
	column names for this mapping.
join-no-fkcol-name-adapt: "{0}" does not supply a name for at least one \
	declared join column.  Since this join can involve multiple columns or \
	uses constant joins, each column must give either its name or a \
	non-constant target.
join-no-fkcol-target-adapt: "{0}" does not supply a target for join column \
	"{1}".  Since this join can involve multiple columns and the a target \
	column with the same name doesn''t exist, you must give a target explicitly.
join-bad-fktarget: "{0}" defines a target of "{1}" for join column "{2}", but \
	that target does not exist in table "{3}".
join-bad-fktargetcls: "{0}" defines target field "{1}" for join column "{2}", \
	but OpenJPA cannot determine the owning class for that field.
join-bad-fktargetfield: "{0}" defines target field of "{1}" for join column \
	"{2}", but that field does not exist in type "{3}".
join-fktargetfield-cols: "{0}" defines target field "{1}" for join column \
	"{2}", but that field is either unmapped or has multiple columns.
join-mult-fk-tables: "{0}" uses join columns from multiple different tables: \
	"{1}", "{2}"
join-fk-exists: "{0}" marks its join columns as explicitly not having a \
	foreign key delete action, but a database foreign key exists on these \
	columns.
join-defer-fk: "{0}" marks its join columns as having a deferred foreign key, \
	but the existing constraint on these columns is not deferred. OpenJPA cannot \
	change the deferrability of a constraint.
join-create-defer-fk: "{0}" marks its join columns as having a deferred \
	foreign key, but the database dictionary "{1}" reports that it does not \
	support deferred constraints.  Creating an undeferred constraint.
join-unsupported-fk-action: "{0}" uses an unsupported foreign key delete or \
	update action on its join columns.  Reverting to a logical foreign key.
join-const-join: "{0}" attempts to join a constant value to another constant \
	value.
unmapped: Attempt to map "{0}" failed: the owning entity is not mapped.
col-wrong-table: When mapping "{0}" to table "{1}", found a column mapped to \
	illegal table "{2}".
target-wrong-cls: When mapping "{0}", found join with a target-field in class \
	"{1}".  This class does not match the expected source or target mappings \
	for the join of ("{2}", "{3}").
no-equiv-mapped-by: "{0}" does not have a valid mapping.  It declares that it \
	is mapped by "{2}", but "{1}", a subclass of its declared type, does not \
	inherit that relation field.
cant-inverse: "{0}" is not a valid mapping.  Inverse foreign key-based \
	relations to types with unjoined subclasses are not supported.
importexport-instantiate: Could not instantiate library to import \
	or export mapping information.
tool-usage: Usage: java org.apache.openjpa.jdbc.meta.MappingTool\n\
	\t[-properties/-p <properties file or resource>]\n\
	\t[-<property name> <property value>]*\n\
	\t[-file/-f <stdout | output file or resource>]\n\
	\t[-schemaFile/-sf <stdout | output file or resource>]\n\
	\t[-sqlFile/-sql <stdout | output file or resource>]\n\
	\t[-schemaAction/-sa <add | retain | drop | refresh | build | none>]\n\
	\t[-schemas/-s <schemas and tables>]\n\
	\t[-readSchema/-rs <true/t | false/f>]\n\
	\t[-primaryKeys/-pk <true/t | false/f>]\n\
	\t[-foreignKeys/-fk <true/t | false/f>]\n\
	\t[-indexes/-ix <true/t | false/f>]\n\
	\t[-dropTables/-dt <true/t | false/f>]\n\
	\t[-openjpaTables/-ot <true/t | false/f>]\n\
	\t[-dropSequences/-dsq <true/t | false/f>]\n\
	\t[-sequences/-sq <true/t | false/f>]\n\
	\t[-ignoreErrors/-i <true/t | false/f>]\n\
	\t[-action/-a <refresh | add | buildSchema | drop | validate | import \n\
	| export>]\n\
	\t<class name | .java file | .class file | .jdo file | .orm file | \
	.mapping file>*
tool-running: Mapping tool running on type "{0}" with action "{1}".
tool-time: The tool is now reading existing schema information; this process \
	may take some time.  Enable the org.apache.openjpa.jdbc.Schema logging category to see \
	messages about schema data.  Also see the -readSchema tool flag.
tool-record: Recording mapping and schema changes.
bad-store: Your configured MetaDataFactory or MappingFactory plugin does not \
	support storing information.  You must write the information by hand. If \
	you are trying to create a schema using default column and table names, \
	run mappingtool with the "buildSchema" action instead of the \
	"refresh" or "add" actions.
bad-drop: Some of the following mappings may not have been dropped: {0}. \
	Undropped mappings will not affect the system.
no-drop-meta: The schema for type "{0}" may not be dropped, because its \
	mapping could not be parsed.
no-meta: Type "{0}" does not have persistence metadata.
bad-bk-file: Could not create a backup file for "{0}".
running-all-classes: No targets were given.  Running on all classes listed in \
	your configuration, or all persistent classes in the classpath if no \
	classes are configured.  Use -help to display tool usage information.
fatal-change: There has been a fatal change to the definition of "{0}" or its \
	schema since it was last mapped, or the mapping you defined is invalid:\n\
	{1}\nOpenJPA will attempt to create a new mapping.
bad-field-strategy: Field "{0}" declared custom mapping strategy "{1}", but \
	this strategy cannot be instantiated.
bad-cls-strategy: Could not instantiate custom class strategy "{1}" \
	for type "{0}".  Make sure this is a valid ClassStrategy implementation.
bad-discrim-strategy: Could not instantiate custom discriminator strategy \
	"{1}" for type "{0}".  Make sure this is a valid DiscriminatorStrategy \
	implementation.
bad-version-strategy: Could not instantiate custom version strategy \
	"{1}" for type "{0}".  Make sure this is a valid VersionStrategy \
	implementation.
bad-value-handler: "{0}" declared custom value handler "{1}", but this handler \
	cannot be instantiated.
bad-mapped-strategy: The type for "{0}" is mapped to custom strategy "{1}", \
	but this strategy cannot be instantiated.
no-field-strategy: OpenJPA cannot map field "{0}" efficiently.  It is of an \
	unsupported type. The field value will be serialized to a BLOB by default.
max-embed-lob: "{0}" is being mapped with a handler that may not be able to \
	store values over {1} bytes/chars long.
incomplete-join: The system has detected an incomplete join on column "{0}".  \
	When you specify a join between tables, you must join to all the columns \
	of any fields involved.
bad-remap: Column "{0}" cannot be involved in polymorphic table-per-class \
	relationships because its corresponding field is mapped differently in \
	various classes in the hierarchy.
unmap-table: Table "{0}" could not be reverse mapped.  This means that the \
	table does not have a primary key (primary keys are required to establish \
	unique identifiers for all persistent objects) and does not match a known \
	pattern for a table used for cross-reference or value collections.
unmap-cols: The following columns of table "{0}" could not be reverse \
	mapped "{1}".
no-pk-fields: Reverse-mapped type "{0}" is configured to use application \
	identity, but has no primary key fields.
class-code: Writing java code for generated type "{0}".
cant-use-char: Column "{0}" is type CHAR(1), but OpenJPA cannot \
	reverse map it into a Java char because OpenJPA is currently configured to \
	store Java chars into numeric database columns.  To configure OpenJPA to \
	store Java chars into CHAR(1) columns, set the following property:\n\
	openjpa.jdbc.DBDictionary: StoreCharsAsNumbers=false
revtool-running: The reverse mapping tool will run on the database.  The tool \
	is gathering schema information; this process may take some time.  Enable \
	the org.apache.openjpa.jdbc.Schema logging category to see messages about schema data.
revtool-running-file: The reverse mapping tool will run on schema file "{0}".
revtool-map: ReverseMappingTool : generating classes.
revtool-write-code: Writing generated class source code.
revtool-write-appid: Writing generated application identity classes.
revtool-write-metadata: Writing generated metadata.
revtool-gen-annos: Generating annotations.
revtool-usage: Usage: java org.apache.openjpa.jdbc.meta.ReverseMappingTool\n\
	\t[-properties/-p <properties file or resource>]\n\
	\t[-<property name> <property value>]*\n\
	\t[-directory/-d <output directory>]\n\
	\t[-schemas/-s <schema and table list>]\n\
	\t[-package/-pkg <package name>]\n\
	\t[-useSchemaName/-sn <true/t | false/f>]\n\
	\t[-useForeignKeyName/-fkn <true/t | false/f>]\n\
	\t[-nullableAsObject/-no <true/t | false/f>]\n\
	\t[-blobAsObject/-bo <true/t | false/f>]\n\
	\t[-useGenericCollections/-gc <true/t | false/f>]\n\
	\t[-typeMap/-type <types>]\n\
	\t[-primaryKeyOnJoin/-pkj <true/t | false/f>]\n\
	\t[-useDatastoreIdentity/-ds <true/t | false/f>]\n\
	\t[-useBuiltinIdentityClass/-bic <true/t | false/f>]\n\
	\t[-innerIdentityClasses/-inn <true/t | false/f>]\n\
	\t[-identityClassSuffix/-is <suffix>]\n\
	\t[-inverseRelations/-ir <true/t | false/f>]\n\
	\t[-detachable/-det <true/t | false/f>]\n\
	\t[-discriminatorStrategy/-ds <strategy>]\n\
	\t[-versionStrategy/-vs <strategy>]\n\
	\t[-metadata/-md <package | class | none>]\n\
	\t[-annotations/-ann <true/t | false/f>]\n\
	\t[-accessType/-access <field | property>]\n\
	\t[-customizerClass/-cc <full class name>]\n\
	\t[-customizerProperties/-cp <properties file or resource>]\n\
	\t[-customizer/-c.<property name> <property value>]*\n\
	\t[-codeFormat/-cf.<property name> <property value>]*\n\
	\t[.schema file]*
custom-class: Customized name found for class "{0}": will rename as "{1}".
custom-no-class: No customized name found for class "{0}" of table "{1}".
custom-rm-class: Removing class "{0}" of table "{1}" from reverse mapped set.
custom-field: Customized name found for field "{0}" in type "{1}": will \
	rename as "{1}".
custom-no-field: No customized name found for field "{0}" in type "{1}".
custom-rm-field: Removing field "{0}" in type "{1}" from reverse mapped set.
custom-unused-props: The following customizer properties were not used in \
	the reverse mapping process: {0}.
reverse-type: Overriding type mapping for column of type name "{0}" to Java \
	class "{1}".
no-reverse-type: No overridden type mapping for column of type name "{0}".
no-query-res: There is no query result mapping for "{0}" with name "{1}".
null-path: Attempt to add a null or empty path to result type "{1}" in mapping \
	"{0}".
bad-path: Result path "{2}" in result type "{1}" of mapping "{0}" contains \
	invalid fields.
untraversable-path: Result path "{2}" in result type "{1}" of mapping "{0}" \
	attempts to traverse through a non-relation field.
num-cols-path: Result path "{2}" in result type "{1}" of mapping "{0}" \
	attempts to map a field that does not have exactly 1 column.
unique-missing-column: The column "{1}" in a unique constraint in "{0}" on \
	table "{2}" can not be found in the list of available columns "{3}".
unique-no-table: A unique constraint on table "{0}" can not be added to \
	mapping of class "{1}" because the table does neither match its primary \
	table "{2}" nor any of its secondary table(s) "{3}".