You are viewing a plain text version of this content. The canonical link for it is here.
Posted to jdo-dev@db.apache.org by mb...@apache.org on 2019/04/30 16:47:55 UTC
[db-jdo-site] branch test created (now e57ee1e)
This is an automated email from the ASF dual-hosted git repository.
mbo pushed a change to branch test
in repository https://gitbox.apache.org/repos/asf/db-jdo-site.git.
at e57ee1e Very first version of .md files
This branch includes the following new commits:
new e57ee1e Very first version of .md files
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[db-jdo-site] 01/01: Very first version of .md files
Posted by mb...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mbo pushed a commit to branch test
in repository https://gitbox.apache.org/repos/asf/db-jdo-site.git
commit e57ee1e8afcb1a5f6a1e32c2bccd0de4be6cce8d
Author: Michael Bouschen <Mi...@akquinet.de>
AuthorDate: Tue Apr 30 18:47:36 2019 +0200
Very first version of .md files
---
annotations.md | 1567 +++++++++++++++++++++++++++++++++++++++++++++++++++
attach_detach.md | 376 ++++++++++++
class_types.md | 192 +++++++
cvs-usage.md | 135 +++++
dependencies.md | 162 ++++++
downloads.md | 174 ++++++
enhancement.md | 676 ++++++++++++++++++++++
exceptions.md | 173 ++++++
extents.md | 145 +++++
faq.md | 151 +++++
fetchgroups.md | 424 ++++++++++++++
field_types.md | 714 +++++++++++++++++++++++
get-involved.md | 176 ++++++
glossary.md | 156 +++++
guides.md | 133 +++++
impls.md | 179 ++++++
index.md | 267 +++++++++
issuetracking.md | 157 ++++++
javadoc.md | 205 +++++++
jdo_3_0_overview.md | 323 +++++++++++
jdo_dtd.md | 168 ++++++
jdo_v_jpa.md | 178 ++++++
jdo_v_jpa_api.md | 158 ++++++
jdo_v_jpa_orm.md | 184 ++++++
jdocentral.md | 141 +++++
jdoconfig_dtd.md | 169 ++++++
jdohelper.md | 209 +++++++
jdoql.md | 377 +++++++++++++
jdoql_methods.md | 304 ++++++++++
jdoql_result.md | 232 ++++++++
jdoquery_dtd.md | 169 ++++++
mail-lists.md | 159 ++++++
metadata.md | 184 ++++++
newshistory.md | 138 +++++
object_retrieval.md | 199 +++++++
orm_dtd.md | 169 ++++++
pm.md | 347 ++++++++++++
pmf.md | 479 ++++++++++++++++
references.md | 172 ++++++
roadmap.md | 136 +++++
specifications.md | 157 ++++++
state_transition.md | 285 ++++++++++
svn.md | 412 ++++++++++++++
tck.md | 162 ++++++
team-list.md | 171 ++++++
transactions.md | 171 ++++++
why_jdo.md | 186 ++++++
47 files changed, 12301 insertions(+)
diff --git a/annotations.md b/annotations.md
new file mode 100644
index 0000000..5fc4c8b
--- /dev/null
+++ b/annotations.md
@@ -0,0 +1,1567 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO Annotations'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+ - **Annotations**
+ - [jdo DTD/XSD](jdo_dtd.html "jdo DTD/XSD")
+ - [orm DTD/XSD](orm_dtd.html "orm DTD/XSD")
+ - [jdoquery DTD/XSD](jdoquery_dtd.html "jdoquery DTD/XSD")
+ - [jdoconfig DTD/XSD](jdoconfig_dtd.html "jdoconfig DTD/XSD")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO : Annotations[]{#JDO_:_Annotations}
+---------------------------------------
+
+One of the things that JDK 1.5 provides that can be of some use is
+annotations, and JDO provides its own set. When selecting to use
+annotations please bear in mind the following :-
+
+- You must have the **jdo-api** jar in your CLASSPATH since this
+ provides the annotations
+- Annotations should really only be used for attributes of persistence
+ that you won\'t be changing at deployment. Things such as table and
+ column names shouldn\'t really be specified using annotations
+ although it is permitted. Instead it would be better to put such
+ information in an ORM MetaData file.
+- Annotations can be added in two places - for the class as a whole,
+ or for a field in particular.
+- You can annotate fields or getters with field-level information. If
+ you annotate fields then the fields are processed for persistence.
+ If you annotate the methods (getters) then the methods (properties)
+ are processed for persistence.
+- Annotations are prefixed by the @ symbol and can take properties (in
+ brackets after the name, comma-separated)
+
+ Annotation Class/Field/Method Description
+ --------------------------------------------- -------------------- ------------------------------------------------------------------------------------------------------------------------------------------------
+ [\@PersistenceCapable](#PersistenceCapable) Class Specifies that the class/interface is persistent. In the case of an interface this would utilise JDO2\'s \"persistent-interface\" capabilities
+ [\@PersistenceAware](#PersistenceAware) Class Specifies that the class is not persistent but needs to be able to access fields of persistent classes
+ [\@Cacheable](#Cacheable_Class) Class Specifies whether this class can be cached in a Level 2 cache or not.
+ [\@EmbeddedOnly](#EmbeddedOnly) Class Specifies that the class is persistent and can only be persisted embedded in another persistent class
+ [\@DatastoreIdentity](#DatastoreIdentity) Class Specifies the details for generating datastore-identity for this class
+ [\@Version](#Version) Class Specifies any versioning process for objects of this class
+ [\@FetchPlans](#FetchPlans) Class Defines a series of fetch plans
+ [\@FetchPlan](#FetchPlan) Class Defines a fetch plan
+ [\@FetchGroups](#FetchGroups) Class Defines a series of fetch groups for this class
+ [\@FetchGroup](#FetchGroup) Class Defines a fetch group for this class
+ [\@Sequence](#Sequence) Class Defines a sequence for use by this class
+ [\@Queries](#Queries) Class Defines a series of named queries for this class
+ [\@Query](#Query) Class Defines a named query for this class
+ [\@Inheritance](#Inheritance) Class Specifies the inheritance model for persisting this class
+ [\@Discriminator](#Discriminator) Class Specifies any discriminator for this class to be used for determining object types
+ [\@PrimaryKey](#PrimaryKey_Class) Class ORM : Defines the primary key constraint for this class
+ [\@Indices](#Indices) Class ORM : Defines a series of indices for this class
+ [\@Index](#Index_Class) Class ORM : Defines an index for the class as a whole (typically a composite index)
+ [\@Uniques](#Uniques) Class ORM : Defines a series of unique constraints for this class
+ [\@Unique](#Unique_Class) Class ORM : Defines a unique constraint for the class as a whole (typically a composite)
+ [\@ForeignKeys](#ForeignKeys) Class ORM : Defines a series of foreign-keys (typically for non-mapped columns/tables)
+ [\@ForeignKey](#ForeignKey_Class) Class ORM : Defines a foreign-key for the class as a whole (typically for non-mapped columns/tables)
+ [\@Joins](#Joins) Class ORM : Defines a series of joins to secondary tables from this table
+ [\@Join](#Join_Class) Class ORM : Defines a join to a secondary table from this table
+ [\@Columns](#Columns) Class ORM : Defines a series of columns that dont have associated fields (\"unmapped columns\")
+ [\@Persistent](#Persistent) Field/Method Defines the persistence for a field/property of the class
+ [\@Serialized](#Serialized) Field/Method Defines this field as being stored serialised
+ [\@NotPersistent](#NotPersistent) Field/Method Defines this field as being not persisted
+ [\@Transactional](#Transactional) Field/Method Defines this field as being transactional (not persisted, but managed)
+ [\@Cacheable](#Cacheable) Field/Method Specifies whether this field/property can be cached in a Level 2 cache or not.
+ [\@PrimaryKey](#PrimaryKey) Field/Method Defines this field as being (part of) the primary key
+ [\@Element](#Element) Field/Method Defines the details of elements of an array/collection stored in this field
+ [\@Key](#Key) Field/Method Defines the details of keys of a map stored in this field
+ [\@Value](#Value) Field/Method Defines the details of values of a map stored in this field
+ [\@Order](#Order) Field/Method ORM : Defines the details of ordering of an array/collection stored in this field
+ [\@Join](#Join) Field/Method ORM : Defines the join to a join table for a collection/array/map
+ [\@Embedded](#Embedded) Field/Method ORM : Defines that this field is embedded and how it is embedded
+ [\@Columns](#Columns) Field/Method ORM : Defines a series of columns where a field is persisted
+ [\@Column](#Column) Field/Method ORM : Defines a column where a field is persisted
+ [\@Index](#Index) Field/Method ORM : Defines an index for the field
+ [\@Unique](#Unique) Field/Method ORM : Defines a unique constraint for the field
+ [\@ForeignKey](#ForeignKey) Field/Method ORM : Defines a foreign key for the field
+ [\@Extensions](#Extensions) Class/Field/Method Defines a series of JDO extensions
+ [\@Extension](#Extension) Class/Field/Method Defines a JDO extension
+
+\
+[]{#PersistenceCapable}
+
+::: {.section}
+### \@PersistenceCapable[]{#aPersistenceCapable}
+
+This annotation is used when you want to mark a class as persistent. It
+equates to the \<class\> MetaData element (though with only some of its
+attributes). Specified on the **class**.
+
+ Attribute Type Description Default
+ ---------------- ----------------------------- ---------------------------------------------------------------------------- -------------------
+ requiresExtent String Whether an extent is required for this class true
+ embeddedOnly String Whether objects of this class can only be stored embedded in other objects false
+ detachable String Whether objects of this class can be detached false
+ identityType IdentityType Type of identity (APPLICATION, DATASTORE, NONDURABLE) DATASTORE
+ objectIdClass Class Object-id class
+ table String ORM : Name of the table where this class is persisted
+ catalog String ORM : Name of the catalog where this table is persisted
+ schema String ORM : Name of the schema where this table is persisted
+ cacheable String Whether the class can be L2 cached. **From JDO2.2** **true** \| false
+ serializeRead String Whether to default reads of this object type to lock the object false
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable(identityType=IdentityType.APPLICATION)
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#PersistenceAware}
+
+::: {.section}
+### \@PersistenceAware[]{#aPersistenceAware}
+
+This annotation is used when you want to mark a class as being used in
+persistence but not being persistable. That is \"persistence-aware\" in
+JDO terminology. It has no attributes. Specified on the **class**.
+
+::: {.source}
+ @PersistenceAware
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+See the documentation for [Class Types](class_types.html)
+
+\
+\
+:::
+
+[]{#Cacheable_Class}
+
+::: {.section}
+### \@Cacheable[]{#aCacheable}
+
+This annotation is a shortcut for
+\@PersistenceCapable(cacheable={value}) specifying whether the class can
+be cached in a Level 2 cache. Specified on the **class**. The default
+
+ Attribute Type Description Default
+ ----------- -------- -------------------------------- -------------------
+ value String Whether the class is cacheable **true** \| false
+
+::: {.source}
+ @Cacheable("false")
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#EmbeddedOnly}
+
+::: {.section}
+### \@EmbeddedOnly[]{#aEmbeddedOnly}
+
+This annotation is a shortcut for
+\@PersistenceCapable(embeddedOnly=\"true\") meaning that the class can
+only be persisted embedded into another class. It has no attributes.
+Specified on the **class**.
+
+::: {.source}
+ @EmbeddedOnly
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Inheritance}
+
+::: {.section}
+### \@Inheritance[]{#aInheritance}
+
+Annotation used to define the inheritance for a class. Specified on the
+**class**.
+
+ Attribute Type Description Default
+ ---------------- --------------------- ------------------------------------------------------------------------------------------- ---------
+ strategy InheritanceStrategy The inheritance strategy (NEW\_TABLE, SUBCLASS\_TABLE, SUPERCLASS\_TABLE)
+ customStrategy String Name of a custom inheritance strategy (depending on what your JDO implementation supports
+
+::: {.source}
+ @PersistenceCapable
+ @Inheritance(strategy=InheritanceStrategy.NEW_TABLE)
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Discriminator}
+
+::: {.section}
+### \@Discriminator[]{#aDiscriminator}
+
+Annotation used to define a discriminator to be stored with instances of
+this class and is used to determine the types of the objects being
+stored. Specified on the **class**.
+
+ Attribute Type Description Default
+ ----------- ----------------------- --------------------------------------------------------------------------- ---------
+ strategy DiscriminatorStrategy The discriminator strategy (VALUE\_MAP, CLASS\_NAME, NONE)
+ value String Value to use for instances of this type when using strategy of VALUE\_MAP
+ column String ORM : Name of the column to use to store the discriminator
+ indexed String ORM : Whether the discriminator column is to be indexed
+ columns [Column](#Column)\[\] ORM : Column definitions used for storing the discriminator
+
+::: {.source}
+ @PersistenceCapable
+ @Inheritance(strategy=InheritanceStrategy.NEW_TABLE)
+ @Discriminator(strategy=DiscriminatorStrategy.CLASS_NAME)
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#DatastoreIdentity}
+
+::: {.section}
+### \@DatastoreIdentity[]{#aDatastoreIdentity}
+
+Annotation used to define the identity when using datastore-identity for
+the class. Specified on the **class**.
+
+ Attribute Type Description Default
+ ---------------- ----------------------------- ----------------------------------------------------------------------------------------------------------- ---------
+ strategy IdGeneratorStrategy The inheritance strategy (NATIVE, SEQUENCE, IDENTITY, INCREMENT, UUIDSTRING, UUIDHEX)
+ customStrategy String Name of a custom id generation strategy (e.g \"max\", \"auid\"). This overrides the value of \"strategy\"
+ sequence String Name of the sequence to use (when using SEQUENCE strategy) - refer to \@Sequence
+ column String ORM : Name of the column for the datastore identity
+ columns [Column](#Column)\[\] ORM : Column definition for the column(s) for the datastore identity
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ @DatastoreIdentity(strategy=IdGeneratorStrategy.INCREMENT)
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Version}
+
+::: {.section}
+### \@Version[]{#aVersion}
+
+Annotation used to define the versioning details for use with optimistic
+transactions. Specified on the **class**.
+
+ Attribute Type Description Default
+ ------------ ----------------------------- ------------------------------------------------------------------------ ---------
+ strategy VersionStrategy The version strategy (NONE, STATE\_IMAGE, DATE\_TIME, VERSION\_NUMBER)
+ indexed String Whether the version column(s) is indexed
+ column String ORM : Name of the column for the version
+ columns [Column](#Column)\[\] ORM : Column definition for the column(s) for the version
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ @Version(strategy=VersionStrategy.VERSION_NUMBER)
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+See the documentation for [transactions](transactions.html)
+
+\
+\
+:::
+
+[]{#PrimaryKey_Class}
+
+::: {.section}
+### \@PrimaryKey[]{#aPrimaryKey}
+
+Annotation used to define the primary key constraint for a class. Maps
+across to the \<primary-key\> MetaData element. Specified on the
+**class**.
+
+ Attribute Type Description Default
+ ----------- ----------------------- ------------------------------------------------------- ---------
+ name String ORM : Name of the primary key constraint
+ column String ORM : Name of the column for this key
+ columns [Column](#Column)\[\] ORM : Column definition for the column(s) of this key
+
+::: {.source}
+ @PersistenceCapable
+ @PrimaryKey(name="MYCLASS_PK")
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#FetchPlans}
+
+::: {.section}
+### \@FetchPlans[]{#aFetchPlans}
+
+Annotation used to define a set of fetch plans. Specified on the
+**class**. Used by named queries
+
+ Attribute Type Description Default
+ ----------- ----------------------------- --------------------------------------------------- ---------
+ value [FetchPlan](#FetchPlan)\[\] Array of fetch plans - see \@FetchPlan annotation
+
+::: {.source}
+ @PersistenceCapable
+ @FetchPlans({@FetchPlan(name="plan_3", maxFetchDepth=3, fetchGroups={"group1", "group4"}),
+ @FetchPlan(name="plan_4", maxFetchDepth=2, fetchGroups={"group1", "group2"})})
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+See the documentation for [FetchGroups](fetchgroups.html)
+
+\
+\
+:::
+
+[]{#FetchPlan}
+
+::: {.section}
+### \@FetchPlan[]{#aFetchPlan}
+
+Annotation used to define a fetch plan Is equivalent to the
+\<fetch-plan\> metadata element. Specified on the **class**. Used by
+named queries
+
+ Attribute Type Description Default
+ --------------- ------------ ------------------------------------------------------- ---------
+ name String Name of the FetchPlan
+ maxFetchDepth int Maximum fetch depth 1
+ fetchSize int Size hint for fetching query result sets 0
+ fetchGroups String\[\] Names of the fetch groups included in this FetchPlan.
+
+::: {.source}
+ @PersistenceCapable
+ @FetchPlan(name="plan_3", maxFetchDepth=3, fetchGroups={"group1", "group4"})
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+See the documentation for [FetchGroups](fetchgroups.html)
+
+\
+\
+:::
+
+[]{#FetchGroups}
+
+::: {.section}
+### \@FetchGroups[]{#aFetchGroups}
+
+Annotation used to define a set of fetch groups for a class. Specified
+on the **class**.
+
+ Attribute Type Description Default
+ ----------- ------------------------------- ----------------------------------------------------- ---------
+ value [FetchGroup](#FetchGroup)\[\] Array of fetch groups - see \@FetchGroup annotation
+
+::: {.source}
+ @PersistenceCapable
+ @FetchGroups({@FetchGroup(name="one_two", members={@Persistent(name="field1"), @Persistent(name="field2")}),
+ @FetchGroup(name="three", members={@Persistent(name="field3")})})
+ public class MyClass
+ {
+ @Persistent
+ String field1;
+
+ @Persistent
+ String field2;
+
+ @Persistent
+ String field3;
+ ...
+ }
+:::
+
+See the documentation for [FetchGroups](fetchgroups.html)
+
+\
+\
+:::
+
+[]{#FetchGroup}
+
+::: {.section}
+### \@FetchGroup[]{#aFetchGroup}
+
+Annotation used to define a fetch group. Is equivalent to the
+\<fetch-group\> metadata element. Specified on the **class**.
+
+ Attribute Type Description Default
+ ----------- ------------------------------- --------------------------------------------------------------------- ---------
+ name String Name of the fetch group
+ postLoad String Whether to call jdoPostLoad after loading this fetch group
+ members [Persistent](#Persistent)\[\] Definitions of the fields/properties to include in this fetch group
+
+::: {.source}
+ @PersistenceCapable
+ @FetchGroup(name="one_two", members={@Persistent(name="field1"), @Persistent(name="field2")})
+ public class MyClass
+ {
+ @Persistent
+ String field1;
+
+ @Persistent
+ String field2;
+ ...
+ }
+:::
+
+See the documentation for [FetchGroups](fetchgroups.html)
+
+\
+\
+:::
+
+[]{#Sequence}
+
+::: {.section}
+### \@Sequence[]{#aSequence}
+
+Annotation used to define a sequence generator. Is equivalent to the
+\<sequence\> metadata element. Specified on the **class**.
+
+ Attribute Type Description Default
+ ------------------- ----------------------------- ------------------------------------------------------------------------- ---------
+ name String Name of the sequence
+ strategy SequenceStrategy Strategy for the sequence (NONTRANSACTIONAL, CONTIGUOUS, NONCONTIGUOUS)
+ datastoreSequence String Name of a datastore sequence that this maps to
+ factoryClass Class Factory class to use to generate the sequence
+ initialValue int Initial value of the sequence 1
+ allocationSize int Allocation size of the sequence 50
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+\
+\
+:::
+
+[]{#Queries}
+
+::: {.section}
+### \@Queries[]{#aQueries}
+
+Annotation used to define a set of named queries for a class. Specified
+on the **class**.
+
+ Attribute Type Description Default
+ ----------- --------------------- ------------------------------------------- ---------
+ value [Query](#Query)\[\] Array of queries - see \@Query annotation
+
+::: {.source}
+ @PersistenceCapable
+ @Queries({@Query(name="PeopleCalledSmith", language="JDOQL",
+ value="SELECT FROM mydomain.Person WHERE surname == \"Smith\""),
+ @Query(name="PeopleCalledJones", language="JDOQL",
+ value="SELECT FROM mydomain.Person WHERE surname == \"Jones\"")})
+ public class Person
+ {
+ @Persistent
+ String surname;
+
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Query}
+
+::: {.section}
+### \@Query[]{#aQuery}
+
+Annotation used to define a named query. Is equivalent to the \<query\>
+metadata element. Specified on the **class**.
+
+ Attribute Type Description Default
+ -------------- ----------------------------- ----------------------------------------------------------------- ---------
+ name String Name of the query
+ value String The query string itself
+ language String Language of the query (JDOQL, SQL, \...) JDOQL
+ unmodifiable String Whether the query is not modifiable at runtime
+ unique String Whether the query returns unique results (for SQL queries only)
+ resultClass Class Result class to use (for SQL queries only)
+ fetchPlan String Name of a named FetchPlan to use with this query
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ @Query(name="PeopleCalledSmith", language="JDOQL",
+ value="SELECT FROM mydomain.Person WHERE surname == \"Smith\"")
+ public class Person
+ {
+ @Persistent
+ String surname;
+
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Indices}
+
+::: {.section}
+### \@Indices[]{#aIndices}
+
+Annotation used to define a set of indices for a class. Specified on the
+**class**.
+
+ Attribute Type Description Default
+ ----------- --------------------------- ------------------------------------------- ---------
+ value [Index](#Index_Class)\[\] Array of indices - see \@Index annotation
+
+::: {.source}
+ @PersistenceCapable
+ @Indices({@Index(name="MYINDEX_1", members={"field1","field2"}), @Index(name="MYINDEX_2", members={"field3"})})
+ public class Person
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Index_Class}
+
+::: {.section}
+### \@Index[]{#aIndex}
+
+Annotation used to define an index for the class as a whole typically
+being a composite index across multiple columns or fields/properties. Is
+equivalent to the \<index\> metadata element when specified under class.
+Specified on the **class**.
+
+ Attribute Type Description Default
+ ----------- ----------------------- -------------------------------------------------------------- ---------
+ name String ORM : Name of the index
+ table String ORM : Name of the table for the index
+ unique String ORM : Whether the index is unique
+ members String\[\] ORM : Names of the fields/properties that make up this index
+ columns [Column](#Column)\[\] ORM : Columns that make up this index
+
+::: {.source}
+ @PersistenceCapable
+ @Index(name="MY_COMPOSITE_IDX", members={"field1", "field2"})
+ public class MyClass
+ {
+ @Persistent
+ String field1;
+
+ @Persistent
+ String field2;
+
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Uniques}
+
+::: {.section}
+### \@Uniques[]{#aUniques}
+
+Annotation used to define a set of unique constraints for a class.
+Specified on the **class**.
+
+ Attribute Type Description Default
+ ----------- ----------------------------- ------------------------------------------------ ---------
+ value [Unique](#Unique_Class)\[\] Array of constraints - see \@Unique annotation
+
+::: {.source}
+ @PersistenceCapable
+ @Uniques({@Unique(name="MYCONST_1", members={"field1","field2"}), @Unique(name="MYCONST_2", members={"field3"})})
+ public class Person
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Unique_Class}
+
+::: {.section}
+### \@Unique[]{#aUnique}
+
+Annotation used to define a unique constraints for the class as a whole
+typically being a composite constraint across multiple columns or
+fields/properties. Is equivalent to the \<unique\> metadata element when
+specified under class. Specified on the **class**.
+
+ Attribute Type Description Default
+ ----------- ----------------------- ------------------------------------------------------------------- ---------
+ name String ORM : Name of the constraint
+ table String ORM : Name of the table for the constraint
+ deferred String ORM : Whether the constraint is deferred
+ members String\[\] ORM : Names of the fields/properties that make up this constraint
+ columns [Column](#Column)\[\] ORM : Columns that make up this constraint
+
+::: {.source}
+ @PersistenceCapable
+ @Unique(name="MY_COMPOSITE_IDX", members={"field1", "field2"})
+ public class MyClass
+ {
+ @Persistent
+ String field1;
+
+ @Persistent
+ String field2;
+
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#ForeignKeys}
+
+::: {.section}
+### \@ForeignKeys[]{#aForeignKeys}
+
+Annotation used to define a set of foreign-key constraints for a class.
+Specified on the **class**.
+
+ Attribute Type Description Default
+ ----------- ------------------------------------- ------------------------------------------------------- ---------
+ value [ForeignKey](#ForeignKey_Class)\[\] Array of FK constraints - see \@ForeignKey annotation
+
+\
+\
+:::
+
+[]{#ForeignKey_Class}
+
+::: {.section}
+### \@ForeignKey[]{#aForeignKey}
+
+Annotation used to define a foreign-key constraint for the class.
+Specified on the **class**.
+
+ Attribute Type Description Default
+ -------------- ----------------------- ------------------------------------------------------------ ---------------------------
+ name String ORM : Name of the constraint
+ table String ORM : Name of the table that the FK is to
+ deferred String ORM : Whether the constraint is deferred
+ unique String ORM : Whether the constraint is unique
+ deleteAction ForeignKeyAction ORM : Action to apply to the FK to be used on deleting ForeignKeyAction.RESTRICT
+ updateAction ForeignKeyAction ORM : Action to apply to the FK to be used on updating ForeignKeyAction.RESTRICT
+ members String\[\] ORM : Names of the fields/properties that compose this FK.
+ columns [Column](#Column)\[\] ORM : Columns that compose this FK.
+
+\
+\
+:::
+
+[]{#Joins}
+
+::: {.section}
+### \@Joins[]{#aJoins}
+
+Annotation used to define a set of joins (to secondary tables) for a
+class. Specified on the **class**.
+
+ Attribute Type Description Default
+ ----------- ------------------------- ---------------------------------------- ---------
+ value [Join](#Join_Class)\[\] Array of joins - see \@Join annotation
+
+::: {.source}
+ @PersistenceCapable
+ @Joins({@Join(table="MY_OTHER_TABLE", column="MY_PK_COL"),
+ @Join(table="MY_SECOND_TABLE", column="MY_PK_COL")})
+ public class MyClass
+ {
+ @Persistent(table="MY_OTHER_TABLE")
+ String myField;
+
+ @Persistent(table="MY_SECOND_TABLE")
+ String myField2;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Join_Class}
+
+::: {.section}
+### \@Join[]{#aJoin}
+
+Annotation used to specify a join for a secondary table. Specified on
+the **class**.
+
+ Attribute Type Description Default
+ ------------ ----------------------------- ---------------------------------------------------------------------------------------------------- ---------
+ table String ORM : Table name used when joining the PK of a FCO class table to a secondary table.
+ column String ORM : Name of the column used to join to the PK of the primary table (when only one column used)
+ outer String ORM : Whether to use an outer join when retrieving fields/properties stored in the secondary table
+ columns [Column](#Column)\[\] ORM : Name of the colums used to join to the PK of the primary table (when multiple columns used)
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable(name="MYTABLE")
+ @Join(table="MY_OTHER_TABLE", column="MY_PK_COL")
+ public class MyClass
+ {
+ @Persistent(name="MY_OTHER_TABLE")
+ String myField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Columns_Class}
+
+::: {.section}
+### \@Columns[]{#aColumns}
+
+Annotation used to define the columns which have no associated field in
+the class. User should specify a minimum of \@Column \"name\",
+\"jdbcType\", and \"insertValue\". Specified on the **class**.
+
+ Attribute Type Description Default
+ ----------- ----------------------- -------------------------------------------- ---------
+ value [Column](#Column)\[\] Array of columns - see \@Column annotation
+
+::: {.source}
+ @PersistenceCapable
+ @Columns(@Column(name="MY_OTHER_COL", jdbcType="VARCHAR", insertValue="N/A")
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Persistent}
+
+::: {.section}
+### \@Persistent[]{#aPersistent}
+
+Annotation used to define the fields/properties to be persisted. Is
+equivalent to the \<field\> and \<property\> metadata elements.
+Specified on the **field/method**.
+
+ Attribute Type Description Default
+ --------------------- ----------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------
+ persistenceModifier PersistenceModifier Whether the field is persistent (PERSISTENT, TRANSACTIONAL, NONE) \[depends on field type\]
+ defaultFetchGroup String Whether the field is part of the DFG
+ nullValue NullValue Required behaviour when inserting a null value for this field (NONE, EXCEPTION, DEFAULT). NONE
+ embedded String Whether this field as a whole is embedded. Use \@Embedded to specify details.
+ embeddedElement String Whether the element stored in this collection/array field/property is embedded
+ embeddedKey String Whether the key stored in this map field/property is embedded
+ embeddedValue String Whether the value stored in this map field/property is embedded
+ serialized String Whether this field/property as a whole is serialised
+ serializedElement String Whether the element stored in this collection/array field/property is serialised
+ serializedKey String Whether the key stored in this map field/property is serialised
+ serializedValue String Whether the value stored in this map field/property is serialised
+ dependent String Whether this field is dependent, deleting the related object when deleting this object
+ dependentElement String Whether the element stored in this field/property is dependent
+ dependentKey String Whether the key stored in this field/property is dependent
+ dependentValue String Whether the value stored in this field/property is dependent
+ primaryKey String Whether this field is (part of) the primary key false
+ valueStrategy IdGeneratorStrategy Strategy to use when generating values for the field (NATIVE, SEQUENCE, IDENTITY, INCREMENT, UUIDSTRING, UUIDHEX)
+ customValueStrategy String Name of a custom id generation strategy (e.g \"max\", \"auid\"). This overrides the value of \"valueStrategy\"
+ sequence String Name of the sequence when using valueStrategy of SEQUENCE - refer to \@Sequence
+ types Class\[\] Type(s) of field (when using interfaces/reference types).
+ mappedBy String Field in other class when the relation is bidirectional to signify the owner of the relation
+ table String ORM : Name of the table where this field is persisted. If this field is a collection/map/array then the table refers to a join table, otherwise this refers to a secondary table.
+ name String Name of the field when defining an embedded field.
+ columns [Column](#Column)\[\] ORM : Column definition(s) for the columns into which this field is persisted. This is only typically used when specifying columns of a field of an embedded class.
+ cacheable String Whether the field/property can be L2 cached. **From JDO2.2** **true** \| false
+ extensions [Extension](#Extension)\[\] Vendor extensions
+ recursionDepth int Recursion depth for this field when fetching. **Only applicable when specified within \@FetchGroup** 1
+ loadFetchGroup String Name of a fetch group to activate when a load of this field is initiated (due to it being currently unloaded). Not used for getObjectById, queries, extents etc. Better to use \@FetchGroup and define your groups
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Persistent(primaryKey="true")
+ String myField;
+ ...
+ }
+:::
+
+See the documentation for [Field Types](field_types.html)
+
+\
+\
+:::
+
+[]{#Serialized}
+
+::: {.section}
+### \@Serialized[]{#aSerialized}
+
+This annotation is a shortcut for \@Persistent(serialized=\"true\")
+meaning that the field is stored serialized. It has no attributes.
+Specified on the **field/method**.
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Serialized
+ Object myField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#NotPersistent}
+
+::: {.section}
+### \@NotPersistent[]{#aNotPersistent}
+
+This annotation is a shortcut for
+\@Persistent(persistenceModifier=PersistenceModifier.NONE) meaning that
+the field/property is not persisted. It has no attributes. Specified on
+the **field/method**.
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @NotPersistent
+ String myOtherField;
+ ...
+ }
+:::
+
+See the documentation for [Field Types](field_types.html)
+
+\
+\
+:::
+
+[]{#Transactional}
+
+::: {.section}
+### \@Transactional[]{#aTransactional}
+
+This annotation is a shortcut for
+\@Persistent(persistenceModifier=PersistenceModifier.TRANSACTIONAL)
+meaning that the field/property is not persisted yet managed. It has no
+attributes. Specified on the **field/method**.
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Transactional
+ String myOtherField;
+ ...
+ }
+:::
+
+See the documentation for [Field Types](field_types.html)
+
+\
+\
+:::
+
+[]{#Cacheable}
+
+::: {.section}
+### \@Cacheable[]{#aCacheable}
+
+This annotation is a shortcut for \@Persistent(cacheable={value})
+specifying whether the field/property can be cached in a Level 2 cache.
+Specified on the **field/property**. The default
+
+ Attribute Type Description Default
+ ----------- -------- ----------------------------------------- -------------------
+ value String Whether the field/property is cacheable **true** \| false
+
+::: {.source}
+ public class MyClass
+ {
+ @Cacheable("false")
+ Collection elements;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#PrimaryKey}
+
+::: {.section}
+### \@PrimaryKey[]{#aPrimaryKey}
+
+This annotation is a shortcut for \@Persistent(primaryKey=\"true\")
+meaning that the field/property is part of the primary key for the
+class. No attributes are needed when specified like this. Specified on
+the **field/method**.
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @PrimaryKey
+ String myOtherField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Element}
+
+::: {.section}
+### \@Element[]{#aElement}
+
+Annotation used to define the element for any collection/array to be
+persisted. Maps across to the \<collection\>, \<array\> and \<element\>
+MetaData elements. Specified on the **field/method**.
+
+ Attribute Type Description Default
+ -------------------- ----------------------------- -------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------
+ types Class\[\] Type(s) of element When using an array is not needed. When using a collection will be taken from the collection definition if using generics, otherwise must be specified.
+ embedded String Whether the element is embedded into a join table
+ serialized String Whether the element is serialised into the join table
+ dependent String Whether the element objects are dependent when deleting the owner collection/array
+ mappedBy String Field in the element class that represents this object (when the relation is bidirectional)
+ embeddedMapping [Embedded](#Embedded)\[\] Definition of any embedding of the (persistable) element. Only 1 \"Embedded\" should be provided
+ table String ORM : Name of the table for this element
+ column String ORM : Name of the column for this element
+ foreignKey String ORM : Name of any foreign-key constraint to add
+ generateForeignKey String ORM : Whether to generate a FK constraint for the element (when not specifying the name)
+ deleteAction ForeignKeyAction ORM : Action to be applied to the foreign key for this element for action upon deletion
+ updateAction ForeignKeyAction ORM : Action to be applied to the foreign key for this element for action upon update
+ index String ORM : Name of any index constraint to add
+ indexed String ORM : Whether this element column is indexed
+ unique String ORM : Whether this element column is unique
+ uniqueKey String ORM : Name of any unique key constraint to add
+ columns [Column](#Column)\[\] ORM : Column definition for the column(s) of this element
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Element(types=mydomain.MyElementClass.class, dependent="true")
+ Collection myField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Order}
+
+::: {.section}
+### \@Order[]{#aOrder}
+
+Annotation used to define the ordering of an order-based
+Collection/array to be persisted. Maps across to the \<order\> MetaData
+element. Specified on the **field/method**.
+
+ Attribute Type Description Default
+ ------------ ----------------------------- --------------------------------------------------------------------------------------- ---------
+ mappedBy String ORM : Field in the element class that represents the ordering of the collection/array
+ column String ORM : Name of the column for this order
+ columns [Column](#Column)\[\] ORM : Column definition for the column(s) of this order
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Element(types=mydomain.MyElementClass.class, dependent="true")
+ @Order(column="ORDER_IDX")
+ Collection myField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Key}
+
+::: {.section}
+### \@Key[]{#aKey}
+
+Annotation used to define the key for any map to be persisted. Maps
+across to the \<map\> and \<key\> MetaData elements. Specified on the
+**field/method**.
+
+ Attribute Type Description Default
+ -------------------- ----------------------------- ---------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------
+ types Class\[\] Type(s) of key. When using generics will be taken from the Map definition, otherwise must be specified
+ embedded String Whether the key is embedded into a join table
+ serialized String Whether the key is serialised into the join table
+ dependent String Whether the key objects are dependent when deleting the owner map
+ mappedBy String Used to specify the field in the value class where the key is stored (optional).
+ embeddedMapping [Embedded](#Embedded)\[\] Definition of any embedding of the (persistable) key. Only 1 \"Embedded\" should be provided
+ table String ORM : Name of the table for this key
+ column String ORM : Name of the column for this key
+ foreignKey String ORM : Name of any foreign-key constraint to add
+ generateForeignKey String ORM : Whether to generate a FK constraint for the key (when not specifying the name)
+ deleteAction ForeignKeyAction ORM : Action to be applied to the foreign key for this key for action upon deletion
+ updateAction ForeignKeyAction ORM : Action to be applied to the foreign key for this key for action upon update
+ index String ORM : Name of any index constraint to add
+ indexed String ORM : Whether this key column is indexed
+ uniqueKey String ORM : Name of any unique key constraint to add
+ unique String ORM : Whether this key column is unique
+ columns [Column](#Column)\[\] ORM : Column definition for the column(s) of this key
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Key(types=java.lang.String.class)
+ Map myField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Value}
+
+::: {.section}
+### \@Value[]{#aValue}
+
+Annotation used to define the value for any map to be persisted. Maps
+across to the \<map\> and \<value\> MetaData elements. Specified on the
+**field/method**.
+
+ Attribute Type Description Default
+ -------------------- ----------------------------- ------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------
+ types Class\[\] Type(s) of value. When using generics will be taken from the Map definition, otherwise must be specified
+ embedded String Whether the value is embedded into a join table
+ serialized String Whether the value is serialised into the join table
+ dependent String Whether the value objects are dependent when deleting the owner map
+ mappedBy String Used to specify the field in the key class where the value is stored (optional).
+ embeddedMapping [Embedded](#Embedded)\[\] Definition of any embedding of the (persistable) value. Only 1 \"Embedded\" should be provided
+ table String ORM : Name of the table for this value
+ column String ORM : Name of the column for this value
+ foreignKey String ORM : Name of any foreign-key constraint to add
+ deleteAction ForeignKeyAction ORM : Action to be applied to the foreign key for this value for action upon deletion
+ generateForeignKey String ORM : Whether to generate a FK constraint for the value (when not specifying the name)
+ updateAction ForeignKeyAction ORM : Action to be applied to the foreign key for this value for action upon update
+ index String ORM : Name of any index constraint to add
+ indexed String ORM : Whether this value column is indexed
+ uniqueKey String ORM : Name of any unique key constraint to add
+ unique String ORM : Whether this value column is unique
+ columns [Column](#Column)\[\] ORM : Column definition for the column(s) of this value
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Key(types=java.lang.String.class)
+ @Value(types=mydomain.MyValueClass.class, dependent="true")
+ Map myField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Join}
+
+::: {.section}
+### \@Join[]{#aJoin}
+
+Annotation used to specify a join to a join table for a
+collection/array/map. Specified on the **field/method**.
+
+ Attribute Type Description Default
+ -------------------- ----------------------------- -------------------------------------------------------------------------------------------- ---------
+ table String ORM : Name of the table
+ column String ORM : Name of the column to join our PK to in the join table (when only one column used)
+ primaryKey String ORM : Name of any primary key constraint to add for the join table
+ generatePrimaryKey String ORM : Whether to generate a PK constraint on the join table (when not specifying the name)
+ foreignKey String ORM : Name of any foreign-key constraint to add
+ generateForeignKey String ORM : Whether to generate a FK constraint on the join table (when not specifying the name)
+ index String ORM : Name of any index constraint to add
+ indexed String ORM : Whether the join column(s) is indexed
+ uniqueKey String ORM : Name of any unique constraint to add
+ unique String ORM : Whether the join column(s) has a unique constraint
+ columns [Column](#Column)\[\] ORM : Name of the columns to join our PK to in the join table (when multiple columns used)
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Persistent
+ @Element(types=mydomain.MyElement.class)
+ @Join(table="MYCLASS_ELEMENTS", column="MYCLASS_ELEMENTS_PK")
+ Collection myField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Embedded}
+
+::: {.section}
+### \@Embedded[]{#aEmbedded}
+
+Annotation used to define that the field contents is embedded into the
+same table as this field Maps across to the \<embedded\> MetaData
+element. Specified on the **field/method**.
+
+ Attribute Type Description Default
+ --------------------- ------------------------------- ------------------------------------------------------------------------------------------------------------------------------ ---------
+ ownerMember String ORM : The field/property in the embedded object that links back to the owning object (where it has a bidirectional relation)
+ nullIndicatorColumn String ORM : The column in the embedded object used to judge if the embedded object is null.
+ nullIndicatorValue String ORM : The value in the null column to interpret the object as being null.
+ members [Persistent](#Persistent)\[\] ORM : Field/property definitions for this embedding.
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Embedded(members={
+ @Persistent(name="field1", columns=@Column(name="OTHER_FLD_1")),
+ @Persistent(name="field2", columns=@Column(name="OTHER_FLD_2"))
+ }
+ MyOtherClass myField;
+ ...
+ }
+
+ @PersistenceCapable
+ @EmbeddedOnly
+ public class MyOtherClass
+ {
+ @Persistent
+ String field1;
+
+ @Persistent
+ String field2;
+ }
+:::
+
+\
+\
+:::
+
+[]{#Columns}
+
+::: {.section}
+### \@Columns[]{#aColumns}
+
+Annotation used to define the columns into which a field is persisted.
+If the field is persisted into a single column then \@Column should be
+used. Specified on the **field/method**.
+
+ Attribute Type Description Default
+ ----------- ----------------------- --------------------------------------------- ---------
+ value [Column](#Column)\[\] Array of columns - see \@Columns annotation
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Persistent
+ @Columns({@Column(name="RED"), @Column(name="GREEN"), @Column(name="BLUE"), @Column(name="ALPHA")})
+ Color myField;
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Column}
+
+::: {.section}
+### \@Column[]{#aColumn}
+
+Annotation used to define that the colum where a field is persisted. Is
+equivalent to the \<column\> metadata element when specified under
+field. Specified on the **field/method** (and within other annotations).
+
+ Attribute Type Description Default
+ -------------- ----------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------- ---------
+ name String ORM : Name of the column
+ target String ORM : Column in the other class that this maps to
+ targetMember String ORM : Field/Property in the other class that this maps to
+ jdbcType String ORM : JDBC Type to use for persisting into this column
+ sqlType String ORM : SQL Type to use for persisting into this column
+ length int ORM : Max length of data to store in this column
+ scale int ORM : Max number of floating points of data to store in this column
+ allowsNull String ORM : Whether null is allowed to be persisted into this column
+ defaultValue String ORM : Default value to persist into this column. If you want the default to be NULL, then put this as \"\#NULL\"
+ insertValue String ORM : Value to insert into this column when it is an \"unmapped\" column. If you want the inserted value to be NULL, then put this as \"\#NULL\"
+ position int Position of this column in the owning table (0 = first)
+ extensions [Extension](#Extension)\[\] Vendor extensions
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Persistent
+ @Column(name="MYCOL", jdbcType="VARCHAR", length=40)
+ String field1;
+
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Index}
+
+::: {.section}
+### \@Index[]{#aIndex}
+
+Annotation used to define that this field is indexed. Is equivalent to
+the \<index\> metadata element when specified under field. Specified on
+the **field/method**.
+
+ Attribute Type Description Default
+ ----------- -------- ----------------------------------- ---------
+ name String ORM : Name of the index
+ unique String ORM : Whether the index is unique
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Persistent
+ @Index(name="MYFIELD1_IDX")
+ String field1;
+
+ @Persistent
+ @Index(name="MYFIELD2_IDX", unique="true")
+ String field2;
+
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Unique}
+
+::: {.section}
+### \@Unique[]{#aUnique}
+
+Annotation used to define that this field has a unique constraint. Is
+equivalent to the \<unique\> metadata element when specified under
+field. Specified on the **field/method**.
+
+ Attribute Type Description Default
+ ----------- -------- ------------------------------------------ ---------
+ name String ORM : Name of the constraint
+ deferred String ORM : Whether the constraint is deferred
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Persistent
+ @Unique(name="MYFIELD1_IDX")
+ String field1;
+
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#ForeignKey}
+
+::: {.section}
+### \@ForeignKey[]{#aForeignKey}
+
+Annotation used to define the foreign key for a relationship field. Is
+equivalent to the \<foreign-key\> metadata element when specified under
+field. Specified on the **field/method**.
+
+ Attribute Type Description Default
+ -------------- ------------------ -------------------------------------------------------- ---------------------------
+ name String ORM : Name of the constraint
+ deferred String ORM : Whether the constraint is deferred
+ unique String ORM : Whether the constraint is unique
+ deleteAction ForeignKeyAction ORM : Action to apply to the FK to be used on deleting ForeignKeyAction.RESTRICT
+ updateAction ForeignKeyAction ORM : Action to apply to the FK to be used on updating ForeignKeyAction.RESTRICT
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ @Persistent
+ @ForeignKey(name="MYFIELD1_FK", deleteAction=ForeignKeyAction.RESTRICT)
+ String field1;
+
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Extensions}
+
+::: {.section}
+### \@Extensions[]{#aExtensions}
+
+Annotation used to define a set of extensions specific to the JDO2
+implementation being used. Specified on the **class** or **field**.
+
+ Attribute Type Description Default
+ ----------- ----------------------------- -------------------------------------------------- ---------
+ value [Extension](#Extension)\[\] Array of extensions - see \@Extension annotation
+
+::: {.source}
+ @PersistenceCapable
+ @Extensions({@Extension(vendorName="MyJDOImpl", key="firstExtension", value="myValue"),
+ @Extension(vendorName="MyJDOImpl", key="secondExtension", value="myValue")})
+ public class Person
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+
+[]{#Extension}
+
+::: {.section}
+### \@Extension[]{#aExtension}
+
+Annotation used to define an extension specific to a particular JDO
+implementation. Is equivalent to the \<extension\> metadata element.
+Specified on the **class** or **field**.
+
+ Attribute Type Description Default
+ ------------ -------- ------------------------ ---------
+ vendorName String Name of the JDO vendor
+ key String Key for the extension
+ value String Value of the extension
+
+::: {.source}
+ @PersistenceCapable
+ @Extension(vendorName="MyJDOImpl", key="RunFast", value="true")
+ public class Person
+ {
+ ...
+ }
+:::
+
+\
+\
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/attach_detach.md b/attach_detach.md
new file mode 100644
index 0000000..d13d54e
--- /dev/null
+++ b/attach_detach.md
@@ -0,0 +1,376 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - Attach/Detach'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- **Attach-Detach**
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO Attach/Detach[]{#JDO_AttachDetach}
+--------------------------------------
+
+JDO provides an interface to the persistence of objects. JDO 1.0
+doesn\'t provide a way of taking an object that was just persisted and
+just work on it and update the persisted object later. The user has to
+copy the fields manually and copy them back to the persisted object
+later. JDO 2.0 introduces a new way of handling this situation, by
+**detaching** an object from the persistence graph, allowing it to be
+worked on in the users application. It can then be **attached** to the
+persistence graph later. Please refer to [Object
+Lifecycle](state_transition.html) for where this fits in. The first
+thing to do to use a class with this facility is to tag it as
+\"detachable\". This is done by adding the attribute
+
+::: {.source}
+ <class name="MyClass" detachable="true">
+:::
+
+This acts as an instruction to the [enhancement
+process](enhancement.html) to add methods necessary to utilise the
+attach/detach process.
+
+The following code fragment highlights how to use the attach/detach
+mechanism
+
+::: {.source}
+ Product working_product=null;
+ Transaction tx=pm.currentTransaction();
+ try
+ {
+ tx.begin();
+
+ Product prod=new Product(name,description,price);
+ pm.makePersistent(prod);
+
+ // Detach the product for use
+ working_product = (Product)pm.detachCopy(prod);
+
+ tx.commit();
+ }
+ catch (Exception e)
+ {
+ // Handle the exception
+ }
+ finally
+ {
+ if (tx.isActive())
+ {
+ tx.rollback();
+ }
+ }
+
+ // Work on the detached object in our application
+ working_product.setPrice(new_price);
+
+ ...
+
+ // Reattach the updated object
+ tx = pm.currentTransaction();
+ try
+ {
+ tx.begin();
+
+ Product attached_product = pm.makePersistent(working_product);
+
+ tx.commit();
+ }
+ catch (Exception e)
+ {
+ // Handle the exception
+ }
+ finally
+ {
+ if (tx.isActive())
+ {
+ tx.rollback();
+ }
+ }
+:::
+
+So we now don\'t need to do any manual copying of object fields just
+using a simple call to detach the object, and then attach it again
+later. Here are a few things to note with *attach/detach* :-
+
+- Calling *detachCopy* on an object that is not detachable will return
+ a **transient** instance that is a COPY of the original, so use the
+ COPY thereafter.
+- Calling *detachCopy* on an object that is detachable will return a
+ **detached** instance that is a COPY of the original, so use this
+ COPY thereafter
+- A *detached* object retain the id of its datastore entity. Detached
+ objects should be used where you want to update the objects and
+ attach them later (updating the associated object in the datastore.
+ If you want to create copies of the objects in the datastore with
+ their own identities you should use *makeTransient* instead of
+ *detachCopy*.
+- Calling *detachCopy* will detach all fields of that object that are
+ in the current [Fetch Group](fetchgroups.html) for that class for
+ that *PersistenceManager*.
+- By default the fields of the object that will be detached are those
+ in the *Default Fetch Group*.
+- You should choose your [Fetch Group](fetchgroups.html) carefully,
+ bearing in mind which object(s) you want to access whilst detached.
+ Detaching a relation field will detach the related object as well.
+- If you don\'t detach a field of an object, you [cannot]{.underline}
+ access the value for that field while the object is detached.
+- If you don\'t detach a field of an object, you [can]{.underline}
+ update the value for that field while detached, and thereafter you
+ can access the value for that field.
+- Calling *makePersistent* will return an (attached) copy of the
+ detached object. It will attach all fields that were originally
+ detached, and will also attach any other fields that were modified
+ whilst detached.
+
+[]{#detach_all_on_commit}
+
+::: {.section}
+### Detach All On Commit[]{#Detach_All_On_Commit}
+
+JDO2 also provides a mechanism whereby all objects that were enlisted in
+a transaction are automatically detached when the transaction is
+committed. You can enable this in one of 3 ways. If you want to use this
+mode globally for all *PersistenceManager*s (PMs) from a
+*PersistenceManagerFactory* (PMF) you could either set the PMF property
+\"datanucleus.DetachAllOnCommit\", or you could create your PMF and call
+the PMF method **setDetachAllOnCommit(true)**. If instead you wanted to
+use this mode only for a particular PM, or only for a particular
+transaction for a particular PM, then you can call the PM method
+**setDetachAllOnCommit(true)** before the commit of the transaction, and
+it will apply for all transaction commits thereafter, until turned off
+(**setDetachAllOnCommit(false)**. Here\'s an example
+
+::: {.source}
+ // Create a PMF
+ ...
+
+ // Create an object
+ MyObject my = new MyObject();
+
+ PersistenceManager pm = pmf.getPersistenceManager();
+ Transaction tx = pm.currentTransaction();
+ try
+ {
+ tx.begin();
+
+ // We want our object to be detached when it's been persisted
+ pm.setDetachAllOnCommit(true);
+
+ // Persist the object that we created earlier
+ pm.makePersistent(my);
+
+ tx.commit();
+ // The object "my" is now in detached state and can be used further
+ }
+ finally
+ {
+ if (tx.isActive)
+ {
+ tx.rollback();
+ }
+ }
+:::
+
+\
+:::
+
+[]{#copy_on_attach}
+
+::: {.section}
+### Copy On Attach[]{#Copy_On_Attach}
+
+By default when you are attaching a detached object it will return an
+attached copy of the detached object. JDO2.1 provides a new feature that
+allows this attachment to just migrate the existing detached object into
+attached state.
+
+You enable this by setting the *PersistenceManagerFactory* (PMF)
+property **datanucleus.CopyOnAttach** to false. Alternatively you can
+use the methods *PersistenceManagerFactory.setCopyOnAttach(boolean
+flag)* or *PersistenceManager.setCopyOnAttach(boolean flag)*. If we
+return to the example at the start of this page, this now becomes
+
+::: {.source}
+ // Reattach the updated object
+ pm.setCopyOnAttach(false);
+ tx = pm.currentTransaction();
+ try
+ {
+ tx.begin();
+
+ // working product is currently in detached state
+
+ pm.makePersistent(working_product);
+ // working_product is now in persistent (attached) state
+
+ tx.commit();
+ }
+ catch (Exception e)
+ {
+ // Handle the exception
+ }
+ finally
+ {
+ if (tx.isActive())
+ {
+ tx.rollback();
+ }
+ }
+:::
+
+Please note that if you try to attach two detached objects representing
+the same underlying persistent object within the same transaction (i.e a
+persistent object with the same identity already exists in the level 1
+cache), then a JDOUserException will be thrown.
+
+\
+:::
+
+::: {.section}
+### Serialization of Detachable classes[]{#Serialization_of_Detachable_classes}
+
+During enhancement of Detachable classes, a field called
+*jdoDetachedState* is added to the class definition. This field allows
+reading and changing tracking of detached objects while they are not
+managed by a PersistenceManager.
+
+When serialization occurs on a Detachable object, the *jdoDetachedState*
+field is written to the serialized object stream. On deserialize, this
+field is written back to the new deserialized instance. This process
+occurs transparently to the application. However, if deserialization
+occurs with an un-enhanced version of the class, the detached state is
+lost.
+
+Serialization and deserialization of Detachable classes and un-enhanced
+versions of the same class is only possible if the field
+*serialVersionUID* is added. It\'s recommended during development of the
+class, to define the *serialVersionUID* and make the class to implement
+the *java.io.Serializable* interface, as the following example:
+
+::: {.source}
+ class MyClass implements java.io.Serializable
+ {
+ private static final long serialVersionUID = 2765740961462495537L; // any random value here
+
+ //.... other fields
+ }
+:::
+
+\
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/class_types.md b/class_types.md
new file mode 100644
index 0000000..0ed4cd1
--- /dev/null
+++ b/class_types.md
@@ -0,0 +1,192 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO Class Types'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- **Types of Classes**
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO Class Types[]{#JDO_Class_Types}
+-----------------------------------
+
+JDO provides a means of transparent persistence of objects of user
+defined classes. With JDO there are actually 3 types of classes.
+
+- **Persistence Capable** classes are classes whose instances can be
+ persisted to a datastore. JDO provide the mechanism for persisting
+ these instances, and they are core to JDO. These classes need to be
+ *enhanced* according to a JDO Meta-Data specification before use
+ within a JDO environment.
+- **Persistence Aware** classes are classes that manipulate
+ Persistence Capable instances through direct attribute manipulation.
+ These classes are typically enhanced with very minimal JDO
+ Meta-Data. The enhancement process performs very little changes to
+ these classes.
+- **Normal** classes are classes that aren\'t themselves persistable,
+ and have no knowledge of persistence either. These classes are
+ totally unchanged in JDO, and require no JDO Meta-Data whatsoever.
+
+::: {.section}
+### PersistenceCapable[]{#PersistenceCapable}
+
+Classes are defined as **PersistenceCapable** either by XML MetaData,
+like this
+
+::: {.source}
+ <class name="MyClass">
+ ...
+ </class>
+:::
+
+or, in JDO2.1, using Annotations. Like this
+
+::: {.source}
+ @PersistenceCapable
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+:::
+
+::: {.section}
+### PersistenceAware[]{#PersistenceAware}
+
+Classes are defined as **PersistenceAware** either by XML MetaData, like
+this
+
+::: {.source}
+ <class name="MyClass" persistence-modifier="persistence-aware"/>
+:::
+
+or, in JDO2.1, using Annotations. Like this
+
+::: {.source}
+ @PersistenceAware
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+\
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/cvs-usage.md b/cvs-usage.md
new file mode 100644
index 0000000..5084295
--- /dev/null
+++ b/cvs-usage.md
@@ -0,0 +1,135 @@
+---
+title: 'Java Data Objects (JDO) - CVS'
+---
+
+::: {#banner}
+ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ [](http://db.apache.org/jdo){#projectLogo}[](http://db.apache.org/jdo){#organizationLogo}
+ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+::: {#menuGeneral}
+##### General
+
+- [Home](index.html)
+- [Why JDO?](why_jdo.html)
+- [JDO v JPA](jdo_v_jpa.html)
+- [JDO v JPA : API](jdo_v_jpa_api.html)
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html)
+- [Downloads](downloads.html)
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "External Link"){.externalLink}
+:::
+
+\
+
+::: {#menuJDO_Implementation}
+##### JDO Implementation
+
+- [Specifications](specifications.html)
+- [TCK](tck.html)
+:::
+
+\
+
+::: {#menuJDO_Usage}
+##### JDO Usage
+
+- [Implementations](impls.html)
+- [API Javadoc](javadoc.html)
+- [Types of Classes](class_types.html)
+- [Types of Fields](field_types.html)
+- [MetaData](metadata.html)
+- [Bytecode Enhancement](enhancement.html)
+- [JDOHelper](jdohelper.html)
+- [PersistenceManagerFactory](pmf.html)
+- [PersistenceManager](pm.html)
+- [Transactions](transactions.html)
+- [Object States](state_transition.html)
+- [Object Retrieval](object_retrieval.html)
+- [Extents](extents.html)
+- [Guides](guides.html)
+- [References](references.html)
+- [Exceptions](exceptions.html)
+- [Glossary](glossary.html)
+:::
+
+\
+
+::: {#menuCommunity}
+##### Community
+
+- [Get Involved](get-involved.html)
+- [Project Team](team-list.html)
+- [Mailing Lists](mail-lists.html)
+- [FAQ](faq.html)
+- [Wiki](http://wiki.apache.org/jdo "External Link"){.externalLink}
+:::
+
+\
+
+::: {#menuDevelopment}
+##### Development
+
+- [RoadMap / TODO](roadmap.html)
+- [Source Code](svn.html)
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "External Link"){.externalLink}
+- [Issue Tracking](issuetracking.html)
+- [Dependencies](dependencies.html)
+:::
+
+\
+:::
+:::
+
+::: {#bodyColumn}
+::: {.contentBox}
+::: {.section}
+[]{#Repository}
+
+Repository
+----------
+
+No SCM repository is defined.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+ --------------------------------------------------------
+ {width="100%" height="1"}
+ --------------------------------------------------------
+
+::: {#footer}
+::: {.xright}
+[Be an Apache Software Foundation
+sponsor](http://www.apache.org/foundation/sponsorship.html)\
+[Thanks to ASF sponsors!](http://www.apache.org/foundation/thanks.html)
+:::
+
+::: {.xleft}
+Documentation published: 21 January 2009\
+2005-2009 [Apache Software Foundation](http://www.apache.org/)
+:::
+:::
diff --git a/dependencies.md b/dependencies.md
new file mode 100644
index 0000000..6564ff2
--- /dev/null
+++ b/dependencies.md
@@ -0,0 +1,162 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - Project Dependencies'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- **Dependencies**
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+The Apache JDO Project[]{#The_Apache_JDO_Project}
+-------------------------------------------------
+
+Apache JDO is a sub-project of the Apache DB TLP. It includes two major
+areas:
+
+- JDO 1, Java Specification Request 12, API, Reference Implementation,
+ and Technology Compatibility Kit.
+- JDO 2, Java Specification Request 243, API, and Technology
+ Compatibility Kit. The Reference Implementation is being developed
+ in parallel by [JPOX](http://www.jpox.org){.externalLink}.
+
+The common external dependencies of JDO include the tools used to build
+and test it:
+
+- Subversion
+- Maven
+- Ant
+- JUnit
+
+Other external dependencies of JDO are subproject-specific:
+
+- JDO 2.0 API
+ - Java Transaction API
+- JDO 2.0 TCK
+ - Java Transaction API
+ - Jakarta Commons Logging
+ - Log4j
+ - Apache Derby
+ - Spring Framework Core
+ - JPOX
+ - ASM
+ - Source Forge c3p0
+ - Commons DBCP
+ - Commons Pool
+ - Commons Collections
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/downloads.md b/downloads.md
new file mode 100644
index 0000000..ba04a17
--- /dev/null
+++ b/downloads.md
@@ -0,0 +1,174 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - Downloads'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- **Downloads**
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Latest Official Release[]{#Latest_Official_Release}
+---------------------------------------------------
+
+[JDO 3.1](releases/release-3.1.cgi)  March 20,
+2015
+:::
+
+::: {.section}
+Previous Official Releases[]{#Previous_Official_Releases}
+---------------------------------------------------------
+
+[JDO 3.1-rc1](releases/release-3.1-rc1.cgi) 
+September 22, 2013
+
+[JDO 3.0.1](releases/release-3.0.1.cgi) 
+November 13, 2011
+:::
+
+::: {.section}
+About JDO Releases[]{#About_JDO_Releases}
+-----------------------------------------
+
+A release of JDO includes the JDO API and the Technology Compatibility
+Kit (TCK). The TCK is available only in source form. The API project is
+available as source and binary, and as raw jar files.
+
+- The api project contains source to build jdo-api.jar. The jar file
+ is the only artifact needed for users who wish to compile their
+ programs using the JDO API. It can be downloaded automatically by
+ maven and placed into the local maven repository if you include the
+ proper dependency in your maven project definition. Use groupId
+ javax.jdo, artifactId jdo-api, version 3.0, and define your remote
+ repository as http://www.ibiblio.org/maven. Alternatively, it can be
+ downloaded manually and put into a location of your choice.
+- The tck project contains the JDO Technology Compatibility Kit. The
+ source distribution is the only artifact needed to be downloaded by
+ the user.
+
+All are available for download as source, but if you wish to run the TCK
+you need only download the TCK project. The dependencies will be
+automatically downloaded by maven as jar files.
+
+For information on running the TCK, see [TCK](tck.html). If downloading
+multiple source packages, extract them all into the same directory. This
+will preserve the source dependencies among the projects.
+
+See [Source Code Version Control](svn.html) for information about
+downloading the latest source code for all of the JDO projects.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/enhancement.md b/enhancement.md
new file mode 100644
index 0000000..2f7e4b6
--- /dev/null
+++ b/enhancement.md
@@ -0,0 +1,676 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO Enhancement'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- **Bytecode Enhancement**
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO Enhancement[]{#JDO_Enhancement}
+-----------------------------------
+
+JDO defines a byte-code enhancement process that provides for dirty
+detection of fields. Before a class is used at runtime it is compiled
+and then \"enhanced\" to implement the interface *PersistenceCapable*,
+and optionally also *Detachable*.
+
+We can demonstrate this by taking a sample class, and seeing it before
+and after enhancement. We start with the following class
+
+::: {.source}
+ package org.apache.jdo.test;
+
+ public class A
+ {
+ long id;
+ String name;
+ B b;
+
+ public A(String name)
+ {
+ this.name = name;
+ }
+
+ public void setId(long id)
+ {
+ this.id = id;
+ }
+
+ public void setB(B b)
+ {
+ this.b = b;
+ }
+
+ public String getName()
+ {
+ return name;
+ }
+
+ public B getB()
+ {
+ return b;
+ }
+
+ public long getId()
+ {
+ return id;
+ }
+
+ public String toString()
+ {
+ return "A : id=" + id + " [" + name + "] b=\"" + b + "\"";
+ }
+ }
+:::
+
+and require it to be *PersistenceCapable* and *Detachable*. The
+enhancement process needs to intercept all updates of the fields of the
+class (id, name, b) as well as add on the necessary
+*PersistenceCapable*, *Detachable* methods. After \"enhancement\" it
+becomes
+
+::: {.source}
+ package org.apache.jdo.test;
+ import java.util.BitSet;
+
+ import javax.jdo.JDODetachedFieldAccessException;
+ import javax.jdo.JDOFatalInternalException;
+ import javax.jdo.PersistenceManager;
+ import javax.jdo.identity.LongIdentity;
+ import javax.jdo.spi.Detachable;
+ import javax.jdo.spi.JDOImplHelper;
+ import javax.jdo.spi.JDOPermission;
+ import javax.jdo.spi.PersistenceCapable;
+ import javax.jdo.spi.StateManager;
+
+ public class A implements PersistenceCapable, Detachable
+ {
+ long id;
+ String name;
+ B b;
+ protected transient StateManager jdoStateManager;
+ protected transient byte jdoFlags;
+ protected Object[] jdoDetachedState;
+ private static final byte[] jdoFieldFlags;
+ private static final Class jdoPersistenceCapableSuperclass;
+ private static final Class[] jdoFieldTypes;
+ private static final String[] jdoFieldNames = __jdoFieldNamesInit();
+ private static final int jdoInheritedFieldCount;
+
+ static
+ {
+ jdoFieldTypes = __jdoFieldTypesInit();
+ jdoFieldFlags = __jdoFieldFlagsInit();
+ jdoInheritedFieldCount = __jdoGetInheritedFieldCount();
+ jdoPersistenceCapableSuperclass = __jdoPersistenceCapableSuperclassInit();
+ JDOImplHelper.registerClass(___jdo$loadClass("org.apache.jdo.test.A"),
+ jdoFieldNames, jdoFieldTypes,
+ jdoFieldFlags,
+ jdoPersistenceCapableSuperclass, new A());
+ }
+
+ public void setId(long id)
+ {
+ jdoSetid(this, id);
+ }
+
+ public void setB(B b)
+ {
+ jdoSetb(this, b);
+ }
+
+ public String getName()
+ {
+ return jdoGetname(this);
+ }
+
+ public B getB()
+ {
+ return jdoGetb(this);
+ }
+
+ public long getId()
+ {
+ return jdoGetid(this);
+ }
+
+ public String toString()
+ {
+ return new StringBuilder().append("A : id=").append(jdoGetid(this))
+ .append(" [").append(jdoGetname(this))
+ .append("] b=\"").append(jdoGetb(this))
+ .append("\"").toString();
+ }
+
+ public void jdoCopyKeyFieldsFromObjectId(PersistenceCapable.ObjectIdFieldConsumer fc, Object oid)
+ {
+ if (fc == null)
+ throw new IllegalArgumentException
+ ("ObjectIdFieldConsumer is null");
+ if (!(oid instanceof LongIdentity))
+ throw new ClassCastException
+ ("oid is not instanceof javax.jdo.identity.LongIdentity");
+ LongIdentity o = (LongIdentity) oid;
+ fc.storeLongField(1, o.getKey());
+ }
+
+ protected void jdoCopyKeyFieldsFromObjectId(Object oid)
+ {
+ if (!(oid instanceof LongIdentity))
+ throw new ClassCastException
+ ("key class is not javax.jdo.identity.LongIdentity or null");
+ LongIdentity o = (LongIdentity) oid;
+ id = o.getKey();
+ }
+
+ public final void jdoCopyKeyFieldsToObjectId(Object oid)
+ {
+ throw new JDOFatalInternalException
+ ("It's illegal to call jdoCopyKeyFieldsToObjectId for a class with Single Field Identity.");
+ }
+
+ public final void jdoCopyKeyFieldsToObjectId
+ (PersistenceCapable.ObjectIdFieldSupplier fs, Object oid) {
+ throw new JDOFatalInternalException
+ ("It's illegal to call jdoCopyKeyFieldsToObjectId for a class with Single Field Identity.");
+ }
+
+ public final Object jdoGetObjectId()
+ {
+ if (jdoStateManager != null)
+ return jdoStateManager.getObjectId(this);
+ if (this.jdoIsDetached() != true)
+ return null;
+ return jdoDetachedState[0];
+ }
+
+ public final Object jdoGetVersion()
+ {
+ if (jdoStateManager != null)
+ return jdoStateManager.getVersion(this);
+ if (this.jdoIsDetached() != true)
+ return null;
+ return jdoDetachedState[1];
+ }
+
+ protected final void jdoPreSerialize()
+ {
+ if (jdoStateManager != null)
+ jdoStateManager.preSerialize(this);
+ }
+
+ public final PersistenceManager jdoGetPersistenceManager()
+ {
+ return (jdoStateManager != null
+ ? jdoStateManager.getPersistenceManager(this) : null);
+ }
+
+ public final Object jdoGetTransactionalObjectId()
+ {
+ return (jdoStateManager != null
+ ? jdoStateManager.getTransactionalObjectId(this) : null);
+ }
+
+ public final boolean jdoIsDeleted()
+ {
+ return (jdoStateManager != null ? jdoStateManager.isDeleted(this): false);
+ }
+
+ public final boolean jdoIsDirty()
+ {
+ if (jdoStateManager != null)
+ return jdoStateManager.isDirty(this);
+ if (this.jdoIsDetached() != true)
+ return false;
+ if (((BitSet) jdoDetachedState[3]).length() <= 0)
+ return false;
+ return true;
+ }
+
+ public final boolean jdoIsNew()
+ {
+ return jdoStateManager != null ? jdoStateManager.isNew(this) : false;
+ }
+
+ public final boolean jdoIsPersistent()
+ {
+ return (jdoStateManager != null ? jdoStateManager.isPersistent(this): false);
+ }
+
+ public final boolean jdoIsTransactional()
+ {
+ return (jdoStateManager != null ? jdoStateManager.isTransactional(this): false);
+ }
+
+ public final boolean jdoIsDetached()
+ {
+ if (jdoStateManager == null) {
+ if (jdoDetachedState == null)
+ return false;
+ return true;
+ }
+ return false;
+ }
+
+ public final void jdoMakeDirty(String fieldName)
+ {
+ if (jdoStateManager != null)
+ jdoStateManager.makeDirty(this, fieldName);
+ }
+
+ public final Object jdoNewObjectIdInstance()
+ {
+ return new LongIdentity(getClass(), id);
+ }
+
+ public final Object jdoNewObjectIdInstance(Object key)
+ {
+ if (key == null)
+ throw new IllegalArgumentException("key is null");
+ if (key instanceof String != true)
+ return new LongIdentity(this.getClass(), (Long) key);
+ return new LongIdentity(this.getClass(), (String) key);
+ }
+
+ public final void jdoProvideFields(int[] fieldId)
+ {
+ if (fieldId == null)
+ throw new IllegalArgumentException("argment is null");
+ int i = fieldId.length - 1;
+ if (i >= 0)
+ {
+ do
+ jdoProvideField(fieldId[i]);
+ while (--i >= 0);
+ }
+ }
+
+ public final void jdoReplaceFields(int[] fieldId)
+ {
+ if (fieldId == null)
+ throw new IllegalArgumentException("argument is null");
+ int i = fieldId.length;
+ if (i > 0)
+ {
+ int i_0_ = 0;
+ do
+ jdoReplaceField(fieldId[i_0_]);
+ while (++i_0_ < i);
+ }
+ }
+
+ public final void jdoReplaceFlags()
+ {
+ if (jdoStateManager != null)
+ {
+ A a = this;
+ a.jdoFlags = a.jdoStateManager.replacingFlags(this);
+ }
+ }
+
+ public final synchronized void jdoReplaceStateManager(StateManager stateManager)
+ {
+ if (jdoStateManager != null)
+ {
+ A a = this;
+ a.jdoStateManager = a.jdoStateManager.replacingStateManager(this, stateManager);
+ }
+ else
+ {
+ JDOImplHelper.checkAuthorizedStateManager(sm);
+ jdoStateManager = stateManager;
+ jdoFlags = (byte) 1;
+ }
+ }
+
+ public final synchronized void jdoReplaceDetachedState()
+ {
+ if (jdoStateManager == null)
+ throw new IllegalStateException("state manager is null");
+ A a = this;
+ a.jdoDetachedState = a.jdoStateManager.replacingDetachedState(this, jdoDetachedState);
+ }
+
+ public PersistenceCapable jdoNewInstance(StateManager sm)
+ {
+ A result = new A();
+ A a = result;
+ a.jdoFlags = (byte) 1;
+ a.jdoStateManager = sm;
+ return a;
+ }
+
+ public PersistenceCapable jdoNewInstance(StateManager sm, Object o)
+ {
+ A result = new A();
+ A a = result;
+ a.jdoFlags = (byte) 1;
+ a.jdoStateManager = sm;
+ result.jdoCopyKeyFieldsFromObjectId(o);
+ return a;
+ }
+
+ public void jdoReplaceField(int fieldIndex)
+ {
+ if (jdoStateManager == null)
+ throw new IllegalStateException("state manager is null");
+ switch (fieldIndex)
+ {
+ case 0:
+ {
+ A a = this;
+ a.b = (B) a.jdoStateManager.replacingObjectField(this, fieldIndex);
+ break;
+ }
+ case 1:
+ {
+ A a = this;
+ a.id = a.jdoStateManager.replacingLongField(this, fieldIndex);
+ break;
+ }
+ case 2:
+ {
+ A a = this;
+ a.name = a.jdoStateManager.replacingStringField(this, fieldIndex);
+ break;
+ }
+ default:
+ throw new IllegalArgumentException("out of field index :" + fieldIndex);
+ }
+ }
+
+ public void jdoProvideField(int fieldIndex)
+ {
+ if (jdoStateManager == null)
+ throw new IllegalStateException("state manager is null");
+ switch (fieldIndex)
+ {
+ case 0:
+ jdoStateManager.providedObjectField(this, fieldIndex, b);
+ break;
+ case 1:
+ jdoStateManager.providedLongField(this, fieldIndex, id);
+ break;
+ case 2:
+ jdoStateManager.providedStringField(this, fieldIndex, name);
+ break;
+ default:
+ throw new IllegalArgumentException("out of field index :" + fieldIndex);
+ }
+ }
+
+ protected final void jdoCopyField(A obj, int index)
+ {
+ switch (index)
+ {
+ case 0:
+ b = obj.b;
+ break;
+ case 1:
+ id = obj.id;
+ break;
+ case 2:
+ name = obj.name;
+ break;
+ default:
+ throw new IllegalArgumentException("out of field index :" + index);
+ }
+ }
+
+ public void jdoCopyFields(Object obj, int[] fieldNumbers)
+ {
+ if (jdoStateManager == null)
+ throw new IllegalStateException("state manager is null");
+ if (fieldNumbers == null)
+ throw new IllegalStateException("fieldNumbers is null");
+ if (obj instanceof A != true)
+ throw new IllegalArgumentException("object is not org.apache.jdo.test.A");
+ A me = (A) obj;
+ if (jdoStateManager != me.jdoStateManager)
+ throw new IllegalArgumentException("state manager unmatch");
+ int i = fieldNumbers.length - 1;
+ if (i >= 0)
+ {
+ do
+ jdoCopyField(me, fieldNumbers[i]);
+ while (--i >= 0);
+ }
+ }
+
+ private static final String[] __jdoFieldNamesInit()
+ {
+ return new String[] { "b", "id", "name" };
+ }
+
+ private static final Class[] __jdoFieldTypesInit()
+ {
+ return new Class[] { ___jdo$loadClass("org.apache.jdo.test.B"), Long.TYPE,
+ ___jdo$loadClass("java.lang.String") };
+ }
+
+ private static final byte[] __jdoFieldFlagsInit()
+ {
+ return new byte[] { 10, 24, 21 };
+ }
+
+ protected static int __jdoGetInheritedFieldCount()
+ {
+ return 0;
+ }
+
+ protected static int jdoGetManagedFieldCount()
+ {
+ return 3;
+ }
+
+ private static Class __jdoPersistenceCapableSuperclassInit()
+ {
+ return null;
+ }
+
+ public static Class ___jdo$loadClass(String className)
+ {
+ try
+ {
+ return Class.forName(className);
+ }
+ catch (ClassNotFoundException e)
+ {
+ throw new NoClassDefFoundError(e.getMessage());
+ }
+ }
+
+ private Object jdoSuperClone()
+ throws CloneNotSupportedException
+ {
+ A o = (A) super.clone();
+ o.jdoFlags = (byte) 0;
+ o.jdoStateManager = null;
+ return o;
+ }
+
+ public A()
+ {
+ /* empty */
+ }
+
+ static void jdoSetb(A objPC, B b_m)
+ {
+ if (objPC.jdoStateManager == null)
+ objPC.b = b_m;
+ else
+ objPC.jdoStateManager.setObjectField(objPC, 0, objPC.b, b_m);
+ if (objPC.jdoIsDetached() == true)
+ ((BitSet) objPC.jdoDetachedState[3]).set(0);
+ }
+
+ static B jdoGetb(A objPC)
+ {
+ if (objPC.jdoStateManager != null
+ && !objPC.jdoStateManager.isLoaded(objPC, 0))
+ return (B) objPC.jdoStateManager.getObjectField(objPC, 0, objPC.b);
+ if (objPC.jdoIsDetached() != false
+ && ((BitSet) objPC.jdoDetachedState[2]).get(0) != true
+ && ((BitSet) objPC.jdoDetachedState[3]).get(0) != true)
+ throw new JDODetachedFieldAccessException
+ ("You have just attempted to access field \"b\" yet this field was not detached when you detached the object. " +
+ "Either dont access this field, or detach the field when detaching the object.");
+ return objPC.b;
+ }
+
+ static void jdoSetid(A objPC, long id_n)
+ {
+ objPC.id = id_n;
+ }
+
+ static long jdoGetid(A objPC)
+ {
+ return objPC.id;
+ }
+
+ static void jdoSetname(A objPC, String name_c)
+ {
+ if (objPC.jdoFlags != 0 && objPC.jdoStateManager != null)
+ objPC.jdoStateManager.setStringField(objPC, 2, objPC.name, name_c);
+ else
+ {
+ objPC.name = name_c;
+ if (objPC.jdoIsDetached() == true)
+ ((BitSet) objPC.jdoDetachedState[3]).set(2);
+ }
+ }
+
+ static String jdoGetname(A objPC)
+ {
+ if (objPC.jdoFlags > 0 && objPC.jdoStateManager != null && !objPC.jdoStateManager.isLoaded(objPC, 2))
+ return objPC.jdoStateManager.getStringField(objPC, 2, objPC.name);
+ if (objPC.jdoIsDetached() != false && ((BitSet) objPC.jdoDetachedState[2]).get(2) != true)
+ throw new JDODetachedFieldAccessException
+ ("You have just attempted to access field \"name\" yet this field was not detached when you detached the object." +
+ "Either dont access this field, or detach the field when detaching the object.");
+ return objPC.name;
+ }
+
+ public A(String name)
+ {
+ jdoSetname(this, name);
+ }
+ }
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/exceptions.md b/exceptions.md
new file mode 100644
index 0000000..4960b5d
--- /dev/null
+++ b/exceptions.md
@@ -0,0 +1,173 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO Exceptions'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- **Exceptions**
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO Exceptions[]{#JDO_Exceptions}
+---------------------------------
+
+All exceptions raised by a JDO implementation are runtime exceptions
+which means that you can choose to catch the exceptions or not. The
+reason for JDO using *unchecked* exceptions is that JDO tries to provide
+transparent persistence, and so needs to present the same interface and
+exceptions whatever the state an object has.
+
+::: {.section}
+### JDOException[]{#JDOException}
+
+This is the base class for all JDO exceptions. It is a subclass of
+RuntimeException, and need not be declared or caught.
+
+\
+:::
+
+::: {.section}
+### Can Retry Exceptions[]{#Can_Retry_Exceptions}
+
+
+
+ Exception Description
+ ------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ JDOCanRetryException This is the base class for errors that can be retried.
+ JDOUserException This is the base class for user errors that can be retried.
+ JDODataStoreException This is the base class for datastore errors that can be retried. Any root SQLException that caused this will typically be nested within this exception.
+ JDOObjectNotFoundException This exception is to notify the application that an object does not exist in the datastore. When this exception is thrown during a transaction, there has been no change in the status of the transaction in progress. If this exception is a nested exception thrown during commit, then the transaction is rolled back.
+ JDOUnsupportedOptionException This exception is thrown by an implementation to indicate that it does not implement a JDO optional feature.
+
+\
+:::
+
+::: {.section}
+### Fatal Exceptions[]{#Fatal_Exceptions}
+
+
+
+ Exception Description
+ ------------------------------------ -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ JDOFatalException This is the base class for errors that cannot be retried. This exception generally means that the transaction associated with the PersistenceManager has been rolled back, and the transaction should be abandoned.
+ JDOFatalUserException This is the base class for user errors that cannot be retried.
+ JDOFatalInternalException This is the base class for JDO implementation failures.
+ JDOFatalDataStoreException This is the base class for fatal datastore errors. When this exception is thrown, the transaction has been rolled back. Any root SQLException that caused this will typically be nested within this exception.
+ JDOOptimisticVerificationException This exception is the result of a user commit operation in an optimistic transaction where the verification of new, modified, or deleted instances fails the verification. The user will never see this exception except as a result of commit.
+ JDODetachedFieldAccessException This exception is the result of a user accessing a field of a detached instance, where the field was not copied to the detached instance.
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/extents.md b/extents.md
new file mode 100644
index 0000000..da6ed8e
--- /dev/null
+++ b/extents.md
@@ -0,0 +1,145 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO Extents'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- **Extents**
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO Extents[]{#JDO_Extents}
+---------------------------
+
+JDO implementations manage the persistence of objects into the
+datastore. An **Extent** is a collection of objects of a particular type
+of object that have been persisted. When you define the MetaData for a
+class you can define if the class requires an Extent. The default is
+true. You access the Extent as follows
+
+::: {.source}
+ Extent e = pm.getExtent(MyClass.class, true);
+
+:::
+
+This example will return an Extent that contains all persisted instances
+of the class *MyClass* and its subclasses (the second argument in the
+call). An Extent is useful where you want to restrict a Query to query
+over just that set of objects. It can also be used where you just want
+to retrieve all persisted objects of a type (as an alternative to using
+a Query).
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/faq.md b/faq.md
new file mode 100644
index 0000000..b408af9
--- /dev/null
+++ b/faq.md
@@ -0,0 +1,151 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - FAQ'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- **FAQ**
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+General[]{#General}
+-------------------
+
+**What is JDO?** JDO is Java Data Objects, a datastore-agnostic
+interface for storing Java objects in transactional datastores.
+
+**I\'d like to find out more about the project and possibly contribute.
+What do I do next?** Participation on the project is via the mailing
+list and the source code repository. You join by subscribing to the
+mailing list and participating in discussions. You can help by
+contributing your ideas, enthusiasm, code, documentation, and tests. The
+fundamental tenet of the Apache Software Foundation is that great
+communities build great code. The emphasis is on community; the code
+comes from that. If you want to help, just join the mailing list, see
+what needs to be done, and do it. Welcome!
+
+**Where is the mailing list, and how can I subscribe?** The developers
+mailing list is jdo-dev\@db.apache.org, a high-volume list currently
+receiving from 100 to 300 messages a month.\
+The users mailing list is jdo-user\@db.apache.org.
+
+**Does this project use a wiki?** It does - the [JDO
+wiki](http://wiki.apache.org/jdo){.externalLink} complements the work
+taking place on the mailing list and provides additional information on
+the project.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/fetchgroups.md b/fetchgroups.md
new file mode 100644
index 0000000..2f62728
--- /dev/null
+++ b/fetchgroups.md
@@ -0,0 +1,424 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - Fetch-Groups'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- **Fetch Groups**
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Fetch Groups[]{#Fetch_Groups}
+-----------------------------
+
+When an object is retrieved from the datastore by JDO typically not all
+fields are retrieved immediately. This is because for efficiency
+purposes only particular field types are retrieved in the initial access
+of the object, and then any other objects are retrieved when accessed
+(lazy loading). The group of fields that are loaded is called a **fetch
+group**. There are 3 types of \"fetch groups\" to consider
+
+- [Default Fetch Group](#dfg) : defined in all JDO specs, containing
+ the fields of a class that will be retrieved by default (with no
+ user specification).
+- [Named Fetch Groups](#static) : defined by the JDO2 specification,
+ and defined in MetaData (XML/annotations) with the fields of a class
+ that are part of that fetch group. The definition here is *static*
+- [Dynamic Fetch Groups](#dynamic) : Programmatic definition of fetch
+ groups at runtime via an API
+
+The **fetch group** in use for a class is controled via the *FetchPlan*
+[](http://db.apache.org/jdo/api20/apidocs/javax/jdo/FetchPlan.html){.externalLink}
+interface. To get a handle on the current *FetchPlan* we do
+
+::: {.source}
+ FetchPlan fp = pm.getFetchPlan();
+:::
+
+\
+[]{#dfg}
+
+::: {.section}
+### Default Fetch Group[]{#Default_Fetch_Group}
+
+JDO provides an initial fetch group, comprising the fields that will be
+retrieved when an object is retrieved if the user does nothing to define
+the required behaviour. By default the *default fetch group* comprises
+all fields of the following types :-
+
+- primitives : boolean, byte, char, double, float, int, long, short
+- Object wrappers of primitives : Boolean, Byte, Character, Double,
+ Float, Integer, Long, Short
+- java.lang.String, java.lang.Number, java.lang.Enum
+- java.math.BigDecimal, java.math.BigInteger
+- java.util.Date
+
+If you wish to change the **Default Fetch Group** for a class you can
+update the Meta-Data for the class as follows (for XML)
+
+::: {.source}
+ <class name="MyClass">
+ ...
+ <field name="fieldX" default-fetch-group="true"/>
+ </class>
+:::
+
+or using annotations
+
+::: {.source}
+ @Persistent(defaultFetchGroup="true")
+ SomeType fieldX;
+:::
+
+When a *PersistenceManager* is created it starts with a FetchPlan of the
+\"default\" fetch group. That is, if we call
+
+::: {.source}
+ Collection fetchGroups = fp.getGroups();
+:::
+
+this will have one group, called \"default\". At runtime, if you have
+been using other fetch groups and want to revert back to the default
+fetch group at any time you simply do
+
+::: {.source}
+ fp.setGroup(FetchPlan.DEFAULT);
+:::
+
+\
+:::
+
+[]{#static}
+
+::: {.section}
+### Named Fetch Groups[]{#Named_Fetch_Groups}
+
+As mentioned above, JDO allows specification of users own fetch groups.
+These are specified in the MetaData of the class. For example, if we
+have the following class
+
+::: {.source}
+ class MyClass
+ {
+ String name;
+ HashSet coll;
+ MyOtherClass other;
+ }
+:::
+
+and we want to have the [other]{.underline} field loaded whenever we
+load objects of this class, we define our MetaData as
+
+::: {.source}
+ <package name="mydomain">
+ <class name="MyClass">
+ <field name="name">
+ <column length="100" jdbc-type="VARCHAR"/>
+ </field>
+ <field name="coll" persistence-modifier="persistent">
+ <collection element-type="mydomain.Address"/>
+ <join/>
+ </field>
+ <field name="other" persistence-modifier="persistent"/>
+ <fetch-group name="otherfield">
+ <field name="other"/>
+ </fetch-group>
+ </class>
+ </package>
+:::
+
+or using annotations
+
+::: {.source}
+ @PersistenceCapable
+ @FetchGroup(name="otherfield", members={@Persistent(name="other")})
+ public class MyClass
+ {
+ ...
+ }
+:::
+
+So we have defined a fetch group called \"otherfield\" that just
+includes the field with name *other*. We can then use this at runtime in
+our persistence code.
+
+::: {.source}
+ PersistenceManager pm = pmf.getPersistenceManager();
+ pm.getFetchPlan().addGroup("otherfield");
+
+ ... (load MyClass object)
+:::
+
+By default the *FetchPlan* will include the default fetch group. We have
+changed this above by [adding]{.underline} the fetch group
+\"otherfield\", so when we retrieve an object using this
+*PersistenceManager* we will be retrieving the fields *name* AND *other*
+since they are both in the current *FetchPlan*. We can take the above
+much further than what is shown by defining nested fetch groups in the
+MetaData. In addition we can change the *FetchPlan* just before any
+*PersistenceManager* operation to control what is fetched during that
+operation. The user has full flexibility to add many groups to the
+current **Fetch Plan**. This gives much power and control over what will
+be loaded and when.
+
+The *FetchPlan* applies not just to calls to
+*PersistenceManager.getObjectById()*, but also to
+*PersistenceManager.newQuery()*, *PersistenceManager.getExtent()*,
+*PersistenceManager.detachCopy* and much more besides.
+
+You can read more about **named fetch-groups** and how to use it with
+[**attach/detach**](attach_detach.html)
+:::
+
+[]{#dynamic}
+
+::: {.section}
+### Dynamic Fetch Groups[]{#Dynamic_Fetch_Groups}
+
+The mechanism above provides static fetch groups defined in XML or
+annotations. That is great when you know in advance what fields you want
+to fetch. In some situations you may want to define your fields to fetch
+at run time. This became standard in JDO2.2 It operates as follows
+
+::: {.source}
+ import org.datanucleus.FetchGroup;
+
+ // Create a FetchGroup on the PMF called "TestGroup" for MyClass
+ FetchGroup grp = myPMF.getFetchGroup("TestGroup", MyClass.class);
+ grp.addMember("field1").addMember("field2");
+
+ // Add this group to the fetch plan (using its name)
+ fp.addGroup("TestGroup");
+:::
+
+So we use the DataNucleus PMF as a way of creating a FetchGroup, and
+then register that FetchGroup with the PMF for use by all PMs. We then
+enable our FetchGroup for use in the FetchPlan by using its group name
+(as we do for a static group). The FetchGroup allows you to add/remove
+the fields necessary so you have full API control over the fields to be
+fetched.
+
+\
+:::
+
+::: {.section}
+### Fetch Depth[]{#Fetch_Depth}
+
+The basic fetch group defines which fields are to be fetched. It
+doesn\'t explicitly define how far down an object graph is to be
+fetched. JDO provides two ways of controlling this.
+
+The first is to set the **maxFetchDepth** for the *FetchPlan*. This
+value specifies how far out from the root object the related objects
+will be fetched. A positive value means that this number of
+relationships will be traversed from the root object. A value of -1
+means that no limit will be placed on the fetching traversal. The
+default is 1. Let\'s take an example
+
+::: {.source}
+ public class MyClass1
+ {
+ MyClass2 field1;
+ ...
+ }
+
+ public class MyClass2
+ {
+ MyClass3 field2;
+ ...
+ }
+
+ public class MyClass3
+ {
+ MyClass4 field3;
+ ...
+ }
+:::
+
+and we want to detach *field1* of instances of *MyClass1*, down 2 levels
+- so detaching the initial \"field1\" *MyClass2* object, and its
+\"field2\" *MyClass3* instance. So we define our fetch-groups like this
+
+::: {.source}
+ <class name="MyClass1">
+ ...
+ <fetch-group name="includingField1">
+ <field name="field1"/>
+ </fetch-group>
+ </class>
+ <class name="MyClass2">
+ ...
+ <fetch-group name="includingField2">
+ <field name="field2"/>
+ </fetch-group>
+ </class>
+:::
+
+and we then define the **maxFetchDepth** as 2, like this
+
+::: {.source}
+ pm.getFetchPlan().setMaxFetchDepth(2);
+:::
+
+A further refinement to this global fetch depth setting is to control
+the fetching of recursive fields. This is performed via a MetaData
+setting \"recursion-depth\". A value of 1 means that only 1 level of
+objects will be fetched. A value of -1 means there is no limit on the
+amount of recursion. The default is 1. Let\'s take an example
+
+::: {.source}
+ public class Directory
+ {
+ Collection children;
+ ...
+ }
+:::
+
+::: {.source}
+ <class name="Directory">
+ <field name="children">
+ <collection element-type="Directory"/>
+ </field>
+
+ <fetch-group name="grandchildren">
+ <field name="children" recursion-depth="2"/>
+ </fetch-group>
+ ...
+ </class>
+:::
+
+So when we fetch a Directory, it will fetch 2 levels of the *children*
+field, hence fetching the children and the grandchildren.
+:::
+
+::: {.section}
+### Fetch Size[]{#Fetch_Size}
+
+A FetchPlan can also be used for defining the fetching policy when using
+queries. This can be set using
+
+::: {.source}
+ pm.getFetchPlan().setFetchSize(value);
+:::
+
+The default is *FetchPlan.FETCH\_SIZE\_OPTIMAL* which leaves it to
+DataNucleus to optimise the fetching of instances. A positive value
+defines the number of instances to be fetched. Using
+*FetchPlan.FETCH\_SIZE\_GREEDY* means that all instances will be fetched
+immediately.
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/field_types.md b/field_types.md
new file mode 100644
index 0000000..7042a5d
--- /dev/null
+++ b/field_types.md
@@ -0,0 +1,714 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - Persistable Field Types'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- **Types of Fields**
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Supported Java Types[]{#Supported_Java_Types}
+---------------------------------------------
+
+When persisting a class, a persistence solution needs to know how to
+persist the types of each field in the class. Clearly a persistence
+solution can only support a finite number of Java types. It cannot know
+how to persist every possible type creatable. The JDO specifications
+define lists of types that are required to be supported by all
+implementations of those specifications. This support can be
+conveniently split into two parts
+
+- An object that can be *referred-to* (object reference, providing a
+ relation) and that has an \"identity\" - **First Class Object
+ (FCO)**. JDO requires an implementation to support
+ *PersistenceCapable* types, as well as object/interface fields that
+ refer to *PersistenceCapable* objects.
+- An object that does not have an \"identity\" - **Second Class Object
+ (SCO)**. This is something like a String or Date field in a class.
+ It can also be a Collection, that contains other objects.
+
+\
+
+::: {.section}
+### First-Class (FCO) Types[]{#First-Class_FCO_Types}
+
+JDO requires objects that are **PersistenceCapable** to be **FCO**. In
+addition it supports persisting fields of Interface or java.lang.Object
+type as FCO (since these are just references to PersistenceCapable
+objects).
+
+\
+:::
+
+::: {.section}
+### Second-Class (SCO) Types[]{#Second-Class_SCO_Types}
+
+The table below shows the supported **SCO** java types in JDO2. The
+table also shows the default-fetch-group (DFG) setting for that Java
+type (so whether it is retrieved by default when retrieving an object
+with a field of that type), whether the field is persisted by default
+(if it is \"false\" then you would have to add
+**persistence-modifier=\"persistent\"** to the field for it to be
+persisted by JDO), and whether the java type can be used as part of the
+primary key.
+
+Java Type
+:::
+:::
+:::
+:::
+
+DFG?
+
+Persistent?
+
+PK?
+
+boolean
+
+
+
+
+
+
+
+byte
+
+
+
+
+
+
+
+char
+
+
+
+
+
+
+
+double
+
+
+
+
+
+
+
+float
+
+
+
+
+
+
+
+int
+
+
+
+
+
+
+
+long
+
+
+
+
+
+
+
+short
+
+
+
+
+
+
+
+boolean\[\]
+
+
+
+
+
+
+
+byte\[\]
+
+
+
+
+
+
+
+char\[\]
+
+
+
+
+
+
+
+double\[\]
+
+
+
+
+
+
+
+float\[\]
+
+
+
+
+
+
+
+int\[\]
+
+
+
+
+
+
+
+long\[\]
+
+
+
+
+
+
+
+short\[\]
+
+
+
+
+
+
+
+java.lang.Boolean
+
+
+
+
+
+
+
+java.lang.Byte
+
+
+
+
+
+
+
+java.lang.Character
+
+
+
+
+
+
+
+java.lang.Double
+
+
+
+
+
+
+
+java.lang.Float
+
+
+
+
+
+
+
+java.lang.Integer
+
+
+
+
+
+
+
+java.lang.Long
+
+
+
+
+
+
+
+java.lang.Short
+
+
+
+
+
+
+
+java.lang.Boolean\[\]
+
+
+
+
+
+
+
+java.lang.Byte\[\]
+
+
+
+
+
+
+
+java.lang.Character\[\]
+
+
+
+
+
+
+
+java.lang.Double\[\]
+
+
+
+
+
+
+
+java.lang.Float\[\]
+
+
+
+
+
+
+
+java.lang.Integer\[\]
+
+
+
+
+
+
+
+java.lang.Long\[\]
+
+
+
+
+
+
+
+java.lang.Short\[\]
+
+
+
+
+
+
+
+java.lang.Number
+
+
+
+
+
+
+
+java.lang.Object
+
+
+
+
+
+
+
+java.lang.String
+
+
+
+
+
+
+
+java.lang.String\[\]
+
+
+
+
+
+
+
+java.math.BigDecimal
+
+
+
+
+
+
+
+java.math.BigInteger
+
+
+
+
+
+
+
+java.math.BigDecimal\[\]
+
+
+
+
+
+
+
+java.math.BigInteger\[\]
+
+
+
+
+
+
+
+java.sql.Date
+
+
+
+
+
+
+
+java.sql.Time
+
+
+
+
+
+
+
+java.sql.Timestamp
+
+
+
+
+
+
+
+java.util.ArrayList
+
+
+
+
+
+
+
+java.util.Collection
+
+
+
+
+
+
+
+java.util.Currency
+
+
+
+
+
+
+
+java.util.Date
+
+
+
+
+
+
+
+java.util.Date\[\]
+
+
+
+
+
+
+
+java.util.HashMap
+
+
+
+
+
+
+
+java.util.HashSet
+
+
+
+
+
+
+
+java.util.Hashtable
+
+
+
+
+
+
+
+java.util.LinkedHashMap
+
+
+
+
+
+
+
+java.util.LinkedHashSet
+
+
+
+
+
+
+
+java.util.LinkedList
+
+
+
+
+
+
+
+java.util.List
+
+
+
+
+
+
+
+java.util.Locale
+
+
+
+
+
+
+
+java.util.Locale\[\]
+
+
+
+
+
+
+
+java.util.Map
+
+
+
+
+
+
+
+java.util.Set
+
+
+
+
+
+
+
+java.util.TreeMap
+
+
+
+
+
+
+
+java.util.TreeSet
+
+
+
+
+
+
+
+java.util.Vector
+
+
+
+
+
+
+
+java.io.Serializable
+
+
+
+
+
+
+
+javax.jdo.spi.PersistenceCapable
+
+
+
+
+
+
+
+javax.jdo.spi.PersistenceCapable\[\]
+
+
+
+
+
+
+
+java.lang.Enum
+
+
+
+
+
+
+
+java.lang.Enum\[\]
+
+
+
+
+
+
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/get-involved.md b/get-involved.md
new file mode 100644
index 0000000..59333b9
--- /dev/null
+++ b/get-involved.md
@@ -0,0 +1,176 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - Get Involved'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- **Get Involved**
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+How do I contribute, give feedback, fix bugs and so on?[]{#How_do_I_contribute_give_feedback_fix_bugs_and_so_on}
+----------------------------------------------------------------------------------------------------------------
+
+The Apache JDO project really needs and appreciates any contributions,
+including documentation help, source code and feedback. Suggested
+changes should come in the form of source code and/or very detailed and
+constructive feedback.
+
+- Discussion occurs on the [JDO mailing lists](mail-lists.html)
+- Information on access to the project source code is available
+ [here](svn.html).
+- Bugs and other issues can be posted on the project
+ [JIRA](%20http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630%20){.externalLink}
+- Additional documentation and discussion can be found on the project
+ [wiki](http://wiki.apache.org/jdo/){.externalLink}
+- We have a communications conference call every Friday at 9:00 AM
+ Pacific time. The conference call number is 866 230-6968
+ (international 865 544-7856) code 294-0479\#. During this call we
+ discuss project status, issues, concerns, and strategy. Everyone
+ interested in Apache JDO is welcome and encouraged to participate.
+:::
+
+::: {.section}
+How do I become a committer?[]{#How_do_I_become_a_committer}
+------------------------------------------------------------
+
+If you\'re interested in committing to the project:
+
+- You\'ll need to fill out some legal paperwork and go through a
+ process to get an apache committer account: See [New Committers
+ Guide](http://apache.org/dev/new-committers-guide.html){.external},
+ [Contributors](http://apache.org/dev/contributors.html){.external},
+ and [Committers](http://apache.org/dev/committers.html){.external}
+ for more details.
+
+- After you\'ve received an email from <ro...@apache.org> with your
+ committer account information, change your initial password: Login
+ by \'ssh -l \<username\> people.apache.org\'; run \'passwd\'; run
+ \'svnpasswd\'. See [Committer Subversion
+ Access](http://apache.org/dev/version-control.html){.external}.
+
+- Check out the JDO sources and test your svn account:
+ [SubversionRepository](http://svn.apache.org/viewcvs.cgi/db/jdo/){.externalLink}.
+
+- Sign up for a
+ [WiKi](http://wiki.apache.org/jdo/UserPreferences){.external}
+ account.
+
+- Sign up for an [ASF JIRA](http://issues.apache.org/jira/){.external}
+ account.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/glossary.md b/glossary.md
new file mode 100644
index 0000000..619a212
--- /dev/null
+++ b/glossary.md
@@ -0,0 +1,156 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO Glossary'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- **Glossary**
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO Glossary[]{#JDO_Glossary}
+-----------------------------
+
+JDO utilizes some terminology used elsewhere (e.g J2EE) but also
+introduces some terminology that may be new to people. Below is a
+glossary of some common terms that may be encountered.
+
+ Term Definition
+ ------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- [...]
+ []{#application-identity}application identity When the persistence of a class is defined in a MetaData file, the developer can decide that they want to control the identity of objects of that class. This is called **application identity** because the application has the control.
+ []{#attach-detach}attach/detach When you have an object of a class that is associated with a PersistenceManager it is referred to as being *attached*. If you want to stop persistence of that object you can *detach* the object. This has the effect that any changes to the object will not be persisted, and also that the object can be used outside transactions.
+ []{#datastore-identity}datastore identity When the persistence of a class is defined in a MetaData file, the developer can decide that they want the identity of objects of that class to be defined by the JDO implementation. This is called **datastore identity**
+ []{#default-fetch-group}default-fetch-group (DFG) When a persisted object is retrieved from the datastore its fields can be retrieved with it, or optionally can be retrieved only when needed. If a field is in the **default-fetch-group** it will be retrieved when the object is retrieved. Some field types default to being in the **default-fetch-group** (e.g primitives, wrappers to primtives, java.util.Date) and others (e.g java.util.Set, java.util.List) don\'t.
+ []{#embedded}embedded A field can be defined as embedded if it will be stored as a column in the table of its containing object.
+ []{#enhancer}enhancer JDO 1.0.1 requires the use of a byte-code enhancer that takes the Java compiled classes and \"enhances\" them, adding in information to permit their use in a JDO environment.
+ []{#fco}FCO JDO defines 2 main groups of Java objects. The first is those objects that have an identity. These are termed \"First Class Objects\" or FCO for short.
+ []{#fetchgroup}Fetch Group JDO allows a user to define groups of fields that should be retrieved (fetched) at the same time. These are called a \"fetch group\". The principal \"fetch group\" is the \"default fetch group\", where JDO has rules for what fields are in this group. A user can define their own group, and make this active so that when objects of their type are retrieved, they have control over the fetching process.
+ []{#JDOQL}JDOQL JDO introduces its own Java-like query language as a datastore independent way of retrieving objects from the datastore. This is known as JDOQL (JDO Query Language).
+ []{#nondurable-identity}nondurable identity Where the objects of a class should be unique in the JVM but not in the datastore (where an RDBMS table doesnt have a PK for example).
+ []{#objectid-class}objectid class When an object of a class is persisted, it is assigned an object identity. When the developer has chosen to use [application identity](#application-identity) they can assign a class to represent this identity (as a primary key) - this is the object id class.
+ []{#optimistic-transaction}optimistic transaction When working with long duration transactions it is undesirable to have locking and so the assumption is made that the data being updated by the transaction will not be modified by any other transaction during the course of the (optimistic) transaction. The data is checked just before commit to confirm integrity that no data has been changed. See also [pessimistic transaction](#pessimistic-transaction) for the contrary type w [...]
+ []{#persistence-by-reachability}persistence-by-reachability When you call makePersistent() on an object, the object will be persisted and, in addition, any other objects reachable from that object (via relationships) will also be persisted. This is known as **persistence-by-reachability**. This process is repeated at commit() time when it checks whether these reachable objects are still reachable and, if not, removes them from persistence.
+ []{#persistence-aware}persistence-aware When an class needs to access fields of a persistence capable class directly, it should be enhanced, and is referred to as \"Persistence Aware\". If a class uses field accessor methods then it doesnt need to become \"Persistence Aware\".
+ []{#persistence-capable}persistence-capable (PC) When an class is byte-code enhanced, and has valid MetaData, it is referred to as \"Persistence Capable\". This means that it can be persisted by a JDO implementation.
+ []{#persistence-modifier}persistence-modifier When defining the persistence of a class, the developer can select particular fields to be persisted, and others not depending on their importance in the scope of their application. The **persistence-modifier** defines whether a field is persistent. If this tag is not specified JDO will assign defaults based on the field type (primitives, primitive wrappers, java.util.Data, persistence capable fields, etc are by default pers [...]
+ []{#persistent}persistent This is an object state where the object is persistent in a datastore.
+ []{#pessimistic-transaction}pessimistic transaction This is the default transaction type in JDO, and is suitable for shortlived operations where there is no other blocking activity during the transaction. When data is accessed other transactions are locked out from accessing it until the transaction is complete. See also [optimistic transaction](#optimistic-transaction) for the contrary type which reduces locking.
+ []{#requires-extent}Requires Extent When the persistent of a class is defined, the developer decides if the object will be stored with its own identity (in its own table for example) or whether it will be stored as part of another object. If it will have its own identity, it will require and Extent.
+ []{#sco}SCO JDO defines 2 main groups of Java objects. The second group is those objects that don\'t have an identity. These are termed \"Second Class Objects\" or SCO for short.
+ []{#SQL}SQL JDO allows use of multiple query languages. One of these, for use with RDBMS datastores, is SQL.
+ []{#transient}transient This is an object state where the object is not persistent.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/guides.md b/guides.md
new file mode 100644
index 0000000..eee28cb
--- /dev/null
+++ b/guides.md
@@ -0,0 +1,133 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO Guides'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- **Guides**
+ - [Datastore
+ Replication](guides/replication.html "Datastore Replication")
+ - [JDO and Maven1](guides/maven-jdo.html "JDO and Maven1")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Guides[]{#Guides}
+-----------------
+
+This section provides guides to the process of introducing JDO into your
+application.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/impls.md b/impls.md
new file mode 100644
index 0000000..e68456b
--- /dev/null
+++ b/impls.md
@@ -0,0 +1,179 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - JDO Implementations'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- **Implementations**
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO Implementations[]{#JDO_Implementations}
+-------------------------------------------
+
+To build and run your JDO application, you need a JDO implementation.
+This page lists commercial and non-commercial JDO implementations. For
+information on how vendors certify compliance with the JDO
+specifications, see [TCK](tck.html).
+
+::: {.section}
+### JDO Reference Implementations[]{#JDO_Reference_Implementations}
+
+- **JDO 1.0** :
+ [FOStore](http://jcp.org/aboutJava/communityprocess/final/jsr012/index2.html){.externalLink}
+- **JDO 2.0** : [JPOX
+ 1.1](https://sourceforge.net/projects/jpox/){.externalLink}
+- **JDO 2.1** : [JPOX
+ 1.2](https://sourceforge.net/projects/jpox/){.externalLink}
+- **JDO 2.2** : [DataNucleus AccessPlatform
+ 1.0.1](http://www.datanucleus.org/products/accessplatform.html){.externalLink}
+- **JDO 3.0** : [DataNucleus AccessPlatform
+ 2.1.0](http://www.datanucleus.org/products/accessplatform_2_1/index.html){.externalLink}
+- **JDO 3.1** : [DataNucleus AccessPlatform
+ 3.2.0](http://www.datanucleus.org/products/accessplatform_3_2/index.html){.externalLink}
+
+\
+:::
+
+::: {.section}
+### Implementations[]{#Implementations}
+
+Below is a list of known implementations of JDO, showing the level of
+JDO that the implementation tries to implement, and the type of
+datastore that the implementation supports. You should check the vendors
+website for details of whether the implementation is fully compliant
+with the specification claimed - Apache JDO simply provides visibility
+of known implementations.
+
+ Name License JDO Spec Datastore(s)
+ ---------------------------------------------------------------------------------------------------------------- --------------- ------------------------------ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ [DataNucleus Access Platform](http://www.datanucleus.org){.externalLink} NonCommercial 1.0, 2.0, 2.1, 2.2, 3.0, 3.1 RDBMS, db4o, NeoDatis, LDAP, Excel XLS, Excel OOXML, ODF, XML, JSON, Google BigTable, HBase, Amazon S3, MongoDB, GoogleStorage, Cassandra, OrientDB, Salesforce.com, Neo4j
+ [JDOInstruments](http://www.jdoinstruments.org/){.externalLink} NonCommercial 1.0 JDOInstruments
+ [*JPOX*](http://www.jpox.org){.externalLink} NonCommercial 1.0, 2.0, 2.1 RDBMS, db4o
+ [*Kodo*](http://www.bea.com/kodo){.externalLink} Commercial 1.0, 2.0 RDBMS, XML
+ [ObjectDB for Java/JDO](http://www.objectdb.com/){.externalLink} Commercial 1.0, 2.0 ObjectDB
+ [Objectivity](http://www.objectivity.com/pages/object-database-solutions/java-data-objects.asp){.externalLink} Commercial 1.0 ObjectivityDB
+ [Orient](http://www.orientechnologies.com/cms/){.externalLink} Commercial 1.0 Orient
+ [*hywy\'s PE:J*](http://pejava.tripod.com/index.html){.externalLink} Commercial 1.0 RDBMS
+ [*SignSoft intelliBO*](http://www.signsoft.de/signsoft/en/intelliBO/){.externalLink} Commercial 1.0 intelliBO
+ [*Speedo*](http://speedo.objectweb.org/){.externalLink} NonCommercial 1.0 RDBMS
+ [*TJDO*](http://tjdo.sourceforge.net/){.externalLink} NonCommercial 1.0 RDBMS
+ [Versant](http://www.versant.com/en_US/products/objectdatabase/){.externalLink} Commercial 1.0, 2.0 Versant Object Database
+ [Xcalia](http://www.xcalia.com/xdn/specs/jdo){.externalLink} Commercial 1.0, 2.0 RDBMS, XML, Versant ODBMS, Jalisto, Web services, mainframe transactions and screens (CICS, IMS\...), packaged applications (ERP, CRM,SFA\...), components (EJB\...).
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/index.md b/index.md
new file mode 100644
index 0000000..6232806
--- /dev/null
+++ b/index.md
@@ -0,0 +1,267 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - Home'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- **Home**
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+About Apache JDO[]{#About_Apache_JDO}
+-------------------------------------
+
+Welcome to Apache JDO, a project of the [Apache DB
+project](http://db.apache.org/){.externalLink}. Our goal is a thriving
+community of users and developers of object persistence technology.
+
+Java Data Objects (JDO) is a standard way to access persistent data in
+databases, using plain old Java objects (POJO) to represent persistent
+data. The approach separates data manipulation (done by accessing Java
+data members in the Java domain objects) from database manipulation
+(done by calling the JDO interface methods). This separation of concerns
+leads to a high degree of independence of the Java view of data from the
+database view of the data.
+
+Interfaces are defined for the user\'s view of persistence:
+
+- PersistenceManager: the component responsible for the life cycle of
+ persistent instances, Query factory, and Transaction access
+- Query: the component responsible for querying the datastore and
+ returning persistent instances or values
+- Transaction: the component responsible for initiating and completing
+ transactions
+
+JDO is being developed as a Java Specification Request in the Java
+Community Process. The original JDO 1.0 is
+[JSR-12](http://www.jcp.org/en/jsr/detail?id=12){.externalLink} and the
+current JDO 3.0.1 is
+[JSR-243](http://www.jcp.org/en/jsr/detail?id=243){.externalLink}.
+
+The Apache JDO project is focused on building the JDO API and the TCK
+for compatibility testing of JDO implementations. Commercial and open
+source implementations of JDO are available for relational databases,
+object databases, and file systems. If you need an implementation for
+building a JDO application, see [Implementations](impls.html).
+:::
+
+::: {.section}
+JDO News[]{#JDO_News}
+---------------------
+
+**JDO 3.1 is released**\
+
+> JDO 3.1 has been released. This release contains minor bug fixes. For
+> a complete list of changes (features plus bug fixes) see [JDO 3.1
+> changes](https://issues.apache.org/jira/browse/JDO/fixforversion/12325878){.externalLink}.
+> You can download the release from the [downloads
+> page](downloads.html). You can also use the new release in maven
+> projects simply by referencing the jdo-api artifact in your pom.xml.
+
+**JDO 3.1-rc1 is released**\
+
+> JDO 3.1-rc1 has been released. This release contains minor bug fixes.
+> For a complete list of changes (features plus bug fixes) see [JDO
+> 3.1-rc1
+> changes](https://issues.apache.org/jira/browse/JDO/fixforversion/12314921){.externalLink}.
+> You can download the release from the [downloads
+> page](downloads.html). You can also use the new release in maven
+> projects simply by referencing the jdo-api artifact in your pom.xml.
+
+**JDO 3.0.1 is released**\
+
+> JDO 3.0.1 has been released. This release contains minor bug fixes.
+> For a complete list of changes (features plus bug fixes) see [JDO
+> 3.0.1
+> changes](https://issues.apache.org/jira/browse/JDO/fixforversion/12317950){.externalLink}.
+> You can download the release from the [downloads
+> page](downloads.html). You can also use the new release in maven
+> projects simply by referencing the jdo-api artifact in your pom.xml.
+
+**JDO 3.0 is released**\
+
+> JDO 3.0 has been released. This release contains significant new
+> features for better support of tooling and runtime: enhancer API,
+> dynamic class and metadata generation, locking, database timeouts,
+> query cancel, and exact object ids. For a complete list of changes
+> (features plus bug fixes) see [JDO 3.0
+> changes](https://issues.apache.org/jira/browse/JDO/fixforversion/12313404){.externalLink}.
+> You can download the release from the [downloads
+> page](downloads.html). You can also use the new release in maven
+> projects simply by referencing the jdo-api artifact in your pom.xml.
+
+**JDO 2.2 is released**\
+
+> JDO 2.2 is now available for download from the [downloads
+> page](downloads.html). The JDO 2.2 maintenance release provides
+> support for copyOnAttach control, dynamic fetch groups, level2 caching
+> control via metadata. For details, see [ChangeLog for JSR-0243 JavaTM
+> Data Objects
+> 2.2](http://jcp.org/aboutJava/communityprocess/maintenance/jsr243/243MR2.html){.externalLink}
+
+**JDO 2.1.1 is released**\
+
+> JDO 2.1.1 is now available for download from the [downloads
+> page](downloads.html). This is a minor bug fix release.
+
+**JDO 2.1 is released**\
+
+> JDO 2.1 is now available for download from the [downloads
+> page](downloads.html). The JDO 2.1 maintenance release provides
+> support for JDK 1.5 features,including the use of annotations as a
+> means of specifying mapping. It also includes many corrections and
+> minor changes. For details, see [Change Log for JSR-000243 JavaTM Data
+> Objects
+> 2.0](http://jcp.org/aboutJava/communityprocess/maintenance/jsr243/243ChangeLog.html){.externalLink}
+> (*2007-08-02*)
+
+**JDO 2.0 has been approved by the JCP**\
+
+> JDO 2.0 is now available for download from the [downloads
+> page](downloads.html). JDO 2.0 builds on JDO 1 and includes many
+> features requested by users:
+>
+> - Standard mapping from objects to relational databases
+> - Multi-tier support without use of Data Transfer Objects
+> - Improved query support including projections and aggregates
+> - Stored queries in metadata
+> - Deletion by query
+> - Optimized fetching of object graphs without writing special
+> queries
+> - Extensive List and Map support
+> - Lazy loading of large collections
+> - Improved support for single-field primary keys
+> - Object lifecycle event monitoring
+> - Improved support for bidirectional relationships
+>
+> (*2006-05-03*)
+
+**Java Community Process!**\
+JDO is being developed under the Java Community Process. The Apache JDO
+project is developing the API and the Technology Compatibility Kit for
+the JDO standard. (*2005-07-13*)
+
+**Users!**\
+We\'d love to have you involved. Check out the
+[Wiki](http://wiki.apache.org/jdo){.externalLink}. Check out the
+[Specification](http://www.jcp.org/en/jsr/detail?id=243){.externalLink},
+which has been approved. [Get Involved](./get-involved.html)!
+(*2005-07-13*)
+
+*Archived articles are [here](newshistory.html)*.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/issuetracking.md b/issuetracking.md
new file mode 100644
index 0000000..627b5d4
--- /dev/null
+++ b/issuetracking.md
@@ -0,0 +1,157 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - Issue Tracking'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- **Issue Tracking**
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Process[]{#Process}
+-------------------
+
+The JDO project uses
+[JIRA](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630){.externalLink}
+to track issues.
+
+We use the following workflow for our JIRA issues:
+
+> Open-\>Resolved(\<-\>Reopened)-\>Closed
+
+> When the engineer has fixed an issue, she sets the issue to resolved.
+> The submitter can reopen it if there is some problem with it. When the
+> release in which the issue is fixed ships, the issue is set to closed.
+
+> If the same issue comes up again after release, another JIRA is
+> opened, referring to the original issue. This accommodates fixes being
+> backported (if ever necessary) to dot releases after the original
+> release ships.
+:::
+
+::: {.section}
+View Issues[]{#View_Issues}
+---------------------------
+
+- [Open
+ Issues](http://issues.apache.org/jira/browse/JDO?report=com.atlassian.jira.plugin.system.project:openissues-panel){.externalLink}
+- [Change Log for released
+ versions](http://issues.apache.org/jira/browse/JDO?report=com.atlassian.jira.plugin.system.project:changelog-panel){.externalLink}
+- [Release Notes for released
+ versions](http://issues.apache.org/jira/secure/ReleaseNote.jspa?version=12310830&styleName=Html&projectId=10630&Create=Create){.externalLink}
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/javadoc.md b/javadoc.md
new file mode 100644
index 0000000..913035d
--- /dev/null
+++ b/javadoc.md
@@ -0,0 +1,205 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - JDO Javadoc'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- **API Javadoc**
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Javadoc Formats[]{#Javadoc_Formats}
+-----------------------------------
+
+JDO Javadoc is available in two formats. You can browse the javadoc
+online, or you can download it as a .zip file and unzip it to a local
+directory.
+:::
+
+::: {.section}
+JDO 3.1 javadoc[]{#JDO_3.1_javadoc}
+-----------------------------------
+
+JDO 3.1 is the current release of the Apache JDO implementation of
+JSR-243.
+
+[Browse JDO 3.1 javadoc online](api31/jdo-api-3.1-javadoc/index.html)
+
+[Download JDO 3.1 javadoc](api31/jdo-api-3.1-javadoc.zip)
+:::
+
+::: {.section}
+JDO 3.0 javadoc[]{#JDO_3.0_javadoc}
+-----------------------------------
+
+JDO 3.0 is the Apache JDO implementation of JSR-243.
+
+[Browse JDO 3.0 javadoc online](api30/apidocs/index.html)
+
+[Download JDO 3.0 javadoc](api30/apidocs.zip)
+:::
+
+::: {.section}
+JDO 2.2 javadoc[]{#JDO_2.2_javadoc}
+-----------------------------------
+
+JDO 2.2 is the Maintenance Release 2 of the Apache JDO implementation of
+JSR-243.
+
+[Browse JDO 2.2 javadoc online](api22/apidocs/index.html)
+
+[Download JDO 2.2 javadoc](api22/apidocs.zip)
+:::
+
+::: {.section}
+JDO 2.1 javadoc[]{#JDO_2.1_javadoc}
+-----------------------------------
+
+JDO 2.1 is the Maintenance Release 1 of the Apache JDO implementation of
+JSR-243.
+
+[Browse JDO 2.1 javadoc online](api21/apidocs/index.html)
+
+[Download JDO 2.1 javadoc](api21/apidocs.zip)
+
+[Browse JDO 2.1-legacy javadoc online](api21-legacy/apidocs/index.html)
+
+[Download JDO 2.1-legacy javadoc](api21-legacy/apidocs.zip)
+:::
+
+::: {.section}
+JDO 2.0 javadoc[]{#JDO_2.0_javadoc}
+-----------------------------------
+
+JDO 2.0 is the Apache JDO implementation of JSR-243.
+
+[Browse JDO 2.0 javadoc online](api20/apidocs/index.html)
+
+[Download JDO 2.0 javadoc](api20/apidocs.zip)
+:::
+
+::: {.section}
+JDO 1.1 javadoc[]{#JDO_1.1_javadoc}
+-----------------------------------
+
+JDO 1.1 is the Apache JDO implementation of JSR-12.
+
+[Browse JDO 1.1 javadoc online](api11/apidocs/index.html)
+
+[Download JDO 1.1 javadoc](api11/apidocs.zip)
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdo_3_0_overview.md b/jdo_3_0_overview.md
new file mode 100644
index 0000000..2e65579
--- /dev/null
+++ b/jdo_3_0_overview.md
@@ -0,0 +1,323 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO 3.0 Overview'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- **JDO 3.0 Overview**
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO 3.0 Overview[]{#JDO_3.0_Overview}
+-------------------------------------
+
+::: {.section}
+### Background[]{#Background}
+
+Java Data Objects (JDO) is a specification begun in 2000, with 2 major
+releases JDO1 (2002 under JSR0012) and JDO2 (2006 under JSR0243). It was
+placed under Apache in 2005 and is the rare example of a specification
+that has undergone continual improvement during its lifetime, for the
+last 4 years being developed totally in the open, accepting input from
+everyone.
+
+JDO 3.0 was started in October 2008, and encompasses additions to the
+specification in the areas of a metadata API, an enhancer API, addition
+of cancel/timeout control to queries, and addition of control to the
+locking of objects when read.
+:::
+
+::: {.section}
+### Metadata API[]{#Metadata_API}
+
+To persist Java objects you need to specify which classes are
+persistable, and how they are persisted. This was traditionally handled
+using XML configuration. With the advent of JDK1.5, annotations were
+added as another possible way of defining such information. JDO 3.0
+takes this further and provides a **Metadata API**, allowing runtime
+definition. This is of particular use for systems that don\'t know at
+application startup which classes should be persistable, maybe because
+the class hasn\'t been written yet.
+
+To demonstrate the Metadata API, lets assume that we have a
+PersistenceManagerFactory created for our datastore. So we request a new
+Metadata object.
+
+::: {.source}
+ PersistenceManagerFactory pmf = JDOHelper.getPersistenceManagerFactory(props);
+ JDOMetaData jdomd = pmf.newMetadata();
+:::
+
+So we can now start defining the metadata for the package/class(es) we
+want to persist. The Metadata is structured in a similar way to the XML
+DTD/XSD. So let\'s add a class
+
+::: {.source}
+ ClassMetadata cmd = jdomd.newClassMetadata("test.Client");
+ cmd.setTable("CLIENT").setDetachable(true).setIdentityType(javax.jdo.annotations.IdentityType.DATASTORE);
+ cmd.setPersistenceModifier(javax.jdo.metadata.ClassPersistenceModifier.PERSISTENCE_CAPABLE);
+:::
+
+So we have a class *test.Client* using datastore-identity, that is
+detachable, and is persisted to a table *CLIENT*. As you can see, you
+can chain setters for convenient coding.
+
+::: {.source}
+ InheritanceMetadata inhmd = cmd.newInheritanceMetadata();
+ inhmd.setStrategy(javax.jdo.annotations.InheritanceStrategy.NEW_TABLE);
+ DiscriminatorMetadata dmd = inhmd.newDiscriminatorMetadata();
+ dmd.setColumn("disc").setValue("Client").setStrategy(javax.jdo.annotations.DiscriminatorStrategy.VALUE_MAP);
+ dmd.setIndexed(Indexed.TRUE);
+
+ VersionMetadata vermd = cmd.newVersionMetadata();
+ vermd.setStrategy(javax.jdo.annotations.VersionStrategy.VERSION_NUMBER).setColumn("version");
+ vermd.setIndexed(Indexed.TRUE);
+:::
+
+So we will use \"new-table\" inheritance for this class, and it will
+have a discriminator stored in column *disc* of type \"value-map\". The
+class will also be versioned, using column *version*, that is indexed.
+All of this was for the class as a whole, so let\'s look at the
+fields/properties of the class.
+
+::: {.source}
+ FieldMetadata fmd = cmd.newFieldMetadata("name");
+ fmd.setNullValue(javax.jdo.annotations.NullValue.DEFAULT).setColumn("name").setIndexed(true).setUnique(true);
+:::
+
+So we have a field *name* that is persisted into column *name*, and is
+unique and indexed. The API metadata components all follow the DTD as
+stated earlier, so if our field was a collection we could then define
+*CollectionMetadata* below it.
+
+The only thing left to do is register the metadata with the
+PersistenceManagerFactory, like this
+
+::: {.source}
+ pmf.registerMetadata(jdomd);
+:::
+
+and any contact with the class will now persist according to this API.
+
+You can similarly browse already registered metadata using
+
+::: {.source}
+ ComponentMetadata compmd = pmf.getMetadata("mydomain.MyClass");
+:::
+
+Note that you cannot change already registered metadata with JDO 3.0.
+
+You can view the Javadocs for the Metadata API
+[here](http://db.apache.org/jdo/api30/apidocs/javax/jdo/metadata/package-summary.html){.externalLink}.
+:::
+
+::: {.section}
+### Enhancer API[]{#Enhancer_API}
+
+JDO implementations typically (but aren\'t compelled to) include a
+bytecode enhancement step, allowing for efficient change detection of
+objects. While the Metadata API above is very useful, if we just define
+metadata for a class we still need to enhance the class using this
+metadata. This is where the **Enhancer API** comes in. To start we need
+to get a JDOEnhancer
+
+::: {.source}
+ JDOEnhancer enhancer = JDOHelper.getEnhancer();
+:::
+
+and now that we have the enhancer and want to enhance our class above so
+we need to register our new metadata with it (generate the metadata as
+shown above)
+
+::: {.source}
+ enhancer.registerMetadata(jdomd);
+:::
+
+Now we can handle the enhancement using a separate class loader if
+required (for example if the classes were defined dynamically, e.g by
+ASM)
+
+::: {.source}
+ enhancer.setClassLoader(myClassLoader);
+:::
+
+Finally we select what to enhance, and perform the enhancement
+
+::: {.source}
+ String[] classes = {"test.Client"};
+ enhancer.addClasses(classes);
+ enhancer.enhance();
+:::
+
+So the class is now enhanced and is ready for use.
+
+You can view the Javadocs for the Enhancer API
+[here](http://db.apache.org/jdo/api30/apidocs/index.html){.externalLink}.
+:::
+
+::: {.section}
+### Query Cancel/Timeout API[]{#Query_CancelTimeout_API}
+
+On occasions a query may be inefficient, or may suffer from problems in
+the underlying datastore, and so we don\'t want to affect the
+application. In this case it would make sense to have control over a
+timeout for the query, or be able to cancel it. JDO 3.0 introduces the
+Query cancel/timeout control, via the following new methods to
+*javax.jdo.Query*
+
+::: {.source}
+ void setTimeoutMillis(Integer interval);
+ Integer getTimeoutMillis();
+ void cancelAll();
+ void cancel(Thread thread);
+:::
+
+So we have the ability to cancel a query as required, or just let it
+timeout.
+:::
+
+::: {.section}
+### Control of read objects locking[]{#Control_of_read_objects_locking}
+
+When we are using datastore (pessimistic) transactions it often doesn\'t
+make sense to just lock all objects read in the transaction. For this
+reason JDO 3.0 introduces control over which objects are locked and
+which aren\'t.
+
+In metadata for each class you can specify the \"serialize-read\"
+setting. True will mean that objects of this type will be locked when
+read.
+
+On a Transaction you can override the metadata settings via the
+following method
+
+::: {.source}
+ void setSerializeRead(Boolean serialize);
+ Boolean getSerializeRead();
+:::
+
+On a Query you can override the metadata and Transaction settings via
+the following method
+
+::: {.source}
+ void setSerializeRead(Boolean serialize);
+ Boolean getSerializeRead();
+:::
+:::
+
+This concludes our simple overview of JDO3. We hope you enjoy using it
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdo_dtd.md b/jdo_dtd.md
new file mode 100644
index 0000000..3afd624
--- /dev/null
+++ b/jdo_dtd.md
@@ -0,0 +1,168 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO DTD'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+ - [Annotations](annotations.html "Annotations")
+ - **jdo DTD/XSD**
+ - [orm DTD/XSD](orm_dtd.html "orm DTD/XSD")
+ - [jdoquery DTD/XSD](jdoquery_dtd.html "jdoquery DTD/XSD")
+ - [jdoconfig DTD/XSD](jdoconfig_dtd.html "jdoconfig DTD/XSD")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Meta-Data - JDO[]{#Meta-Data_-_JDO}
+-----------------------------------
+
+JDO defines XML MetaData in **jdo** files as well as **orm** files. As
+always with XML, the metadata must match the defined DTD/XSD for that
+file type. This section describes the content of the **jdo** files. The
+content of **orm** files can be found [here](orm_dtd.html). All **jdo**
+files must contain a valid DTD/DOCTYPE specification. You can use PUBLIC
+or SYSTEM versions of these.
+
+Here are a few examples valid for **jdo** files with DTD specifications
+
+::: {.source}
+ <!DOCTYPE jdo PUBLIC
+ "-//Sun Microsystems, Inc.//DTD Java Data Objects Metadata 3.0//EN"
+ "http://xmlns.jcp.org/dtd/jdo_3_0.dtd">
+
+ <!DOCTYPE jdo SYSTEM "file:/javax/jdo/jdo.dtd">
+:::
+
+\
+
+Here is an example valid for **jdo** files with XSD specification
+
+::: {.source}
+ <?xml version="1.0" encoding="UTF-8" ?>
+ <jdo xmlns="http://xmlns.jcp.org/xml/ns/jdo/jdo"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/jdo/jdo
+ http://xmlns.jcp.org/xml/ns/jdo/jdo_3_0.xsd">
+ ...
+ </jdo>
+:::
+
+Your MetaData should match either the
+[DTD](http://xmlns.jcp.org/dtd/jdo_3_0.dtd){.externalLink} or the
+[XSD](http://xmlns.jcp.org/xml/ns/jdo/jdo_3_0.xsd){.externalLink}
+specification.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdo_v_jpa.md b/jdo_v_jpa.md
new file mode 100644
index 0000000..49dac49
--- /dev/null
+++ b/jdo_v_jpa.md
@@ -0,0 +1,178 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO .v. JPA'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- **JDO v JPA**
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Which Persistence Specification ?[]{#Which_Persistence_Specification_}
+----------------------------------------------------------------------
+
+There are several competing persistence technologies available for Java.
+Two of these are \"standardised\" (via the JCP). When developing your
+application you need to choose the most appropriate technology for your
+needs. **Java Data Objects (JDO)** has been a standard since 2001 with
+the release of JDO1. It was improved with the release of JDO2. Just to
+confuse issues the **Java Persistence API (JPA)** was approved in its
+JPA1 form, and JDO2.1/JDO2.2 provide updates to JDO2 building on some of
+the new features of JPA1. Since then we have had JDO3 adding on extra
+metadata and enhancer standardisation, JPA2 providing criteria queries
+and JPA2.1 adding some further features. Below we show some of the
+differences of these 2 standards to give you assistance in selecting
+what you need. Highlighted in bold are the notable differences where one
+specification provides something not available in the other.
+
+ Feature JDO [...]
+ ------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- [...]
+ JDK Requirement **1.3+** [...]
+ Usage J2EE, J2SE [...]
+ Persistence specification mechanism XML, Annotations, **API** [...]
+ Datastore supported **Any** [...]
+ Restrictions on persisted classes **no-arg constructor (could be added by compiler/enhancer)** [...]
+ Ability to persist \"transient\" fields **Yes** [...]
+ Persist static/final fields No [...]
+ Transactions **Pessimistic**, Optimistic [...]
+ Object Identity **datastore-identity**, application-identity [...]
+ Object Identity generation Sequence, Table, Identity, Auto, **UUID String, UUID Hex** [...]
+ Change objects identity **Throw exception when not allowed** [...]
+ Supported types Java primitive types, wrappers of primitive types, java.lang.String, **java.lang.Number**, java.math.BigInteger, java.math.BigDecimal, **java.util.Currency, java.util.Locale**, java.util.Date, java.sql.Time, java.sql.Date, java.sql.Timestamp, java.io.Serializable, **boolean\[\]**, byte\[\], char\[\], **double\[\], float\[\], int\[\], long\[\], short\[\]**, **java.lang.Object**, **interface**, **Boolean\[\]**, Byte\[\], Character\[\], **Double\ [...]
+ Embedded Fields Embedded persistent objects, **Embedded Collections, Embedded Maps** [...]
+ Access a non-detached field **Throw exception** [...]
+ Inheritance **Each class has its own strategy** [...]
+ Operation cascade default persist, (delete) [...]
+ Operation Cascade configuration delete [...]
+ Query Language JDOQL, SQL, others [...]
+ Query candidates **Candidate without subclasses**, Candidate and its subclasses [...]
+ Query of candidate collection **yes** [...]
+ Query language case sensitivity JDOQL lowercase/UPPERCASE [...]
+ Query language aliases No, but has variables in JDOQL [...]
+ Query Criteria API No, available as extension in QueryDSL [...]
+ Object retrieval control Lazy/Eager control, **fetch groups** [...]
+ Bulk update/delete JDOQL Bulk Delete [...]
+ RDBMS Schema Control Tables, columns, PK columns, **PK constraints**, FK columns, **FK constraints**, **index columns**, **index constraints**, unique key columns, **unique key constraints** [...]
+ ORM Relationships [**Full range of Collection, Map, List, Array, 1-1, 1-N, M-N using PC, Non-PC and interface objects**](jdo_v_jpa_orm.html) [...]
+ Default ORM column size 256 [...]
+ Default ORM identifiers (tables/columns) No [...]
+ Default ORM mappings Yes, JDBC types defined for Java types [...]
+ Caching interface L2 Caching API [...]
+
+As an overall conclusion \"JPA\" is a subset of what is available in
+\"JDO\".
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdo_v_jpa_api.md b/jdo_v_jpa_api.md
new file mode 100644
index 0000000..131f669
--- /dev/null
+++ b/jdo_v_jpa_api.md
@@ -0,0 +1,158 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO .v. JPA : API'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- **JDO v JPA : API**
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDO .v. JPA : API[]{#JDO_.v._JPA_:_API}
+---------------------------------------
+
+The two persistence standards in Java have very similar API\'s on the
+face of it. Here we give a comparison of the method calls and their
+equivalent in the other API.
+
+ -------------------------------------------------------------------------
+ Operation JDO JPA
+ ---------------------- ------------------------- ------------------------
+ Persist Object pm.makePersistent() em.persist
+
+ Update Object pm.makePersistent() em.merge()
+
+ Remove Object pm.deletePersistent() em.remove()
+
+ Retrieve Object pm.getObjectById()\ em.find()
+ pm.getExtent()
+
+ Refresh Object pm.refresh() em.refresh()
+
+ Detach single Object pm.detachCopy() em.detach()
+
+ Flush changes pm.flush() em.flush()
+
+ Access transaction pm.currentTransaction() em.getTransaction()
+
+ New Query pm.newQuery() em.createQuery()
+
+ New Named Query pm.newNamedQuery() em.createNamedQuery()
+
+ New SQL Query pm.newQuery() em.createNativeQuery()
+ -------------------------------------------------------------------------
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdo_v_jpa_orm.md b/jdo_v_jpa_orm.md
new file mode 100644
index 0000000..5ee6d2b
--- /dev/null
+++ b/jdo_v_jpa_orm.md
@@ -0,0 +1,184 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO .v. JPA : Object/Relational Mapping'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- **JDO v JPA : ORM**
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Which ORM specification ?[]{#Which_ORM_specification_}
+------------------------------------------------------
+
+There are 2 prevalent specification in the Java ORM world. JDO provides
+the most complete definition, whilst JPA is the most recent.
+
+::: {.section}
+### Relationships[]{#Relationships}
+
+In this guide we show the different types of ORM relation commonly used,
+and mark against it which specification supports it. This list is not
+yet complete but will be added to to provide a comprehensive list of
+relationship type and where you can find it.
+
+ Field Type Relation JDO JPA
+ ----------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------- ----------------------------------
+ PC [1-1 Unidirectional](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_one.html#uni){.externalLink}  
+ PC [1-1 Bidirectional](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_one.html#bi){.externalLink}  
+ PC [1-1 serialised](http://www.datanucleus.org/products/accessplatform/jdo/orm/serialised.html#PC){.externalLink}  
+ PC [1-1 CompoundIdentity Unidirectional](http://www.datanucleus.org/products/accessplatform/jdo/orm/compound_identity.html#1_1_uni){.externalLink}  
+ PC [1-N CompoundIdentity Collection Bidirectional](http://www.datanucleus.org/products/accessplatform/jdo/orm/compound_identity.html#1_N_coll_bi){.externalLink}  
+ PC [1-N CompoundIdentity Map Bidirectional](http://www.datanucleus.org/products/accessplatform/jdo/orm/compound_identity.html#1_N_map_bi){.externalLink}  
+ Interface [1-1 Unidirectional](http://www.datanucleus.org/products/accessplatform/jdo/orm/interfaces.html){.externalLink}  
+ Interface [1-1 Bidirectional](http://www.datanucleus.org/products/accessplatform/jdo/orm/interfaces.html){.externalLink}  
+ Interface [1-1 serialised](http://www.datanucleus.org/products/accessplatform/jdo/orm/serialised.html#Reference){.externalLink}  ?
+ Collection\<PC\> [1-N ForeignKey Unidirectional Collection](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_collection.html#fk_uni){.externalLink}  
+ Collection\<PC\> [1-N ForeignKey Bidirectional Collection](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_collection.html#fk_bi){.externalLink}  
+ Collection\<PC\> [1-N JoinTable Unidirectional Collection](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_collection.html#join_uni){.externalLink}  
+ Collection\<PC\> [1-N JoinTable Bidirectional Collection](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_collection.html#join_bi){.externalLink}  
+ Collection\<Non-PC\> [1-N JoinTable Collection](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_collection.html#join_nonpc){.externalLink}  
+ Collection\<PC\> [1-N JoinTable Collection using shared JoinTable](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_collection.html#shared_join){.externalLink}  
+ Collection\<PC\> [1-N ForeignKey Collection using shared ForeignKey](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_collection.html#shared_fk){.externalLink}  
+ Collection\<PC\> [M-N JoinTable](http://www.datanucleus.org/products/accessplatform/jdo/orm/many_to_many.html){.externalLink}  
+ Collection\<PC\> [1-N CompoundIdentity Unidirectional](http://www.datanucleus.org/products/accessplatform/jdo/orm/compound_identity.html#1_N_uni){.externalLink}  
+ Collection\<PC\> [1-N serialised Collection](http://www.datanucleus.org/products/accessplatform/jdo/orm/serialised.html#Collection){.externalLink}  
+ Collection\<PC\> [1-N JoinTable Collection of serialised elements](http://www.datanucleus.org/products/accessplatform/jdo/orm/serialised.html#CollectionElements){.externalLink}  
+ List\<PC\> [1-N ForeignKey Unidirectional Indexed List](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_list.html#fk_uni){.externalLink}  
+ List\<PC\> [1-N ForeignKey Bidirectional Indexed List](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_list.html#fk_bi){.externalLink}  
+ List\<PC\> [1-N JoinTable Unidirectional Indexed List](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_list.html#join_uni){.externalLink}  
+ List\<PC\> [1-N JoinTable Bidirectional Indexed List](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_list.html#join_bi){.externalLink}  
+ List\<Non-PC\> [1-N JoinTable Indexed List](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_list.html#join_nonpc){.externalLink}  
+ List\<PC\> [1-N ForeignKey Unidirectional Ordered List](http://www.datanucleus.org/products/accessplatform/jpa/orm/one_to_many_list.html#fk_uni){.externalLink}  
+ List\<PC\> [1-N ForeignKey Bidirectional Ordered List](http://www.datanucleus.org/products/accessplatform/jpa/orm/one_to_many_list.html#fk_bi){.externalLink}  
+ List\<PC\> [1-N JoinTable Unidirectional Ordered List](http://www.datanucleus.org/products/accessplatform/jpa/orm/one_to_many_list.html#join_uni){.externalLink}  
+ List\<PC\> [1-N JoinTable Bidirectional Ordered List](http://www.datanucleus.org/products/accessplatform/jpa/orm/one_to_many_list.html#join_bi){.externalLink}  
+ Map\<PC, PC\> [1-N JoinTable Map](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_map.html#join_pc_pc){.externalLink}  
+ Map\<Non-PC, PC\> [1-N JoinTable Map](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_map.html#join_simple_pc){.externalLink}  
+ Map\<PC, Non-PC\> [1-N JoinTable Map](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_map.html#join_pc_simple){.externalLink}  
+ Map\<Non-PC, Non-PC\> [1-N JoinTable Map](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_map.html#join_simple_simple){.externalLink}  
+ Map\<Non-PC, PC\> [1-N ForeignKey Map Unidirectional (key stored in value)](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_map.html#fk_uni_key){.externalLink}  
+ Map\<Non-PC, PC\> [1-N ForeignKey Map Bidirectional (key stored in value)](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_map.html#fk_bi_key){.externalLink}  
+ Map\<PC, Non-PC\> [1-N ForeignKey Map Unidirectional (value stored in key)](http://www.datanucleus.org/products/accessplatform/jdo/orm/one_to_many_map.html#fk_uni_value){.externalLink}  
+ Map\<PC, PC\> [1-N serialised Map](http://www.datanucleus.org/products/accessplatform/jdo/orm/serialised.html#Map){.externalLink}  
+ Map\<PC, PC\> [1-N JoinTable Map of serialised keys/values](http://www.datanucleus.org/products/accessplatform/jdo/orm/serialised.html#MapKeysValues){.externalLink}  
+ PC\[ \] [1-N ForeignKey Unidirectional Array](http://www.datanucleus.org/products/accessplatform/jdo/orm/arrays.html#fk){.externalLink}  
+ PC\[ \] [1-N JoinTable Unidirectional Array](http://www.datanucleus.org/products/accessplatform/jdo/orm/arrays.html#join){.externalLink}  
+ PC\[ \] [1-N serialised Array](http://www.datanucleus.org/products/accessplatform/jdo/orm/serialised.html#Array){.externalLink}  
+ Non-PC\[ \] [1-N JoinTable Unidirectional Array](http://www.datanucleus.org/products/accessplatform/jdo/orm/arrays.html#join){.externalLink}  
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdocentral.md b/jdocentral.md
new file mode 100644
index 0000000..4098caa
--- /dev/null
+++ b/jdocentral.md
@@ -0,0 +1,141 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - Home'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDOCentral at Apache JDO[]{#JDOCentral_at_Apache_JDO}
+-----------------------------------------------------
+
+Welcome to the new home of JDOCentral!
+
+JDOCentral was a privately maintained site. Apache JDO is home for the
+development of the JDO specification and the TCK. The
+[DataNucleus](http://www.datanucleus.org){.externalLink} site is home
+for the development of the Reference Implementation of the JDO
+specification.
+
+Visit the other pages on the Apache JDO site to find out what\'s going
+on with JDO. Join the [mailing
+lists](http://db.apache.org/jdo/mail-lists.html){.externalLink} to get
+involved and provide feedback.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdoconfig_dtd.md b/jdoconfig_dtd.md
new file mode 100644
index 0000000..69cbbcd
--- /dev/null
+++ b/jdoconfig_dtd.md
@@ -0,0 +1,169 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDOConfig DTD/XSD'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+ - [Annotations](annotations.html "Annotations")
+ - [jdo DTD/XSD](jdo_dtd.html "jdo DTD/XSD")
+ - [orm DTD/XSD](orm_dtd.html "orm DTD/XSD")
+ - [jdoquery DTD/XSD](jdoquery_dtd.html "jdoquery DTD/XSD")
+ - **jdoconfig DTD/XSD**
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Meta-Data - JDOConfig[]{#Meta-Data_-_JDOConfig}
+-----------------------------------------------
+
+JDO allows you to define a file *jdoconfig.xml* that specifies the
+properties for a named PMF. As always with XML, the metadata must match
+the defined DTD/XSD for that file type. This section describes the
+content of the **jdoconfig** files. All **jdoconfig** files must contain
+a valid DTD/DOCTYPE specification. You can use PUBLIC or SYSTEM versions
+of these.
+
+Here are a few examples valid for **jdoconfig** files with DTD
+specifications
+
+::: {.source}
+ <!DOCTYPE jdoconfig PUBLIC
+ "-//Sun Microsystems, Inc.//DTD Java Data Objects Configuration 3.0//EN"
+ "http://xmlns.jcp.org/dtd/jdoconfig_3_0.dtd">
+
+ <!DOCTYPE jdoconfig SYSTEM "file:/javax/jdo/jdoconfig.dtd">
+:::
+
+\
+
+Here is an example valid for **jdoconfig** files with XSD specification
+
+::: {.source}
+ <?xml version="1.0" encoding="UTF-8" ?>
+ <jdoconfig xmlns="http://xmlns.jcp.org/xml/ns/jdo/jdoconfig"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/jdo/jdoconfig
+ http://xmlns.jcp.org/xml/ns/jdo/jdoconfig_3_0.xsd">
+ ...
+ </jdoconfig>
+:::
+
+Your MetaData should match either the
+[DTD](http://xmlns.jcp.org/dtd/jdoconfig_3_0.dtd){.externalLink} or the
+[XSD](http://xmlns.jcp.org/xml/ns/jdo/jdoconfig_3_0.xsd){.externalLink}
+specification.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdohelper.md b/jdohelper.md
new file mode 100644
index 0000000..500a510
--- /dev/null
+++ b/jdohelper.md
@@ -0,0 +1,209 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDOHelper'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- **JDOHelper**
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDOHelper[]{#JDOHelper}
+-----------------------
+
+JDO provides a standard utility that gives access to useful parts of the
+JDO persistence process. This is known as **JDOHelper**
+(javax.jdo.JDOHelper)
+[](api20/apidocs/javax/jdo/JDOHelper.html)
+
+::: {.section}
+### PersistenceManagerFactory methods[]{#PersistenceManagerFactory_methods}
+
+The methods in JDOHelper can be split into categories. Here we start
+with the methods for creating the starting point for persistence, the
+PersistenceManagerFactory (PMF)
+
+- **getPersistenceManagerFactory(Map props)** - creates a PMF given a
+ Map of the properties
+- **getPersistenceManagerFactory(Map props, ClassLoader cl)** -
+ creates a PMF given a Map of the properties, and a ClassLoader to
+ use
+- **getPersistenceManagerFactory(String resource)** - creates a PMF
+ given a resource defining the properties. This can be used to create
+ a named PMF in JDO2.1
+- **getPersistenceManagerFactory(String props, ClassLoader cl)** -
+ creates a PMF given a resource defining the properties, and a
+ ClassLoader to use
+- **getPersistenceManagerFactory(File props)** - creates a PMF given a
+ file containing the properties
+- **getPersistenceManagerFactory(File props, ClassLoader cl)** -
+ creates a PMF given a file containing the properties and a
+ ClassLoader to use
+- **getPersistenceManagerFactory(String jndi, Context ctx)** - creates
+ a PMF given a JNDI resource
+- **getPersistenceManagerFactory(String jndi, Context ctx,
+ ClassLoader cl)** - creates a PMF given a JNDI resource and a
+ ClassLoader to use
+- **getPersistenceManagerFactory(InputStream strm)** - creates a PMF
+ given an InputStream
+- **getPersistenceManagerFactory(InputStream strm, ClassLoader cl)** -
+ creates a PMF given an InputStream and a ClassLoader to use
+
+\
+:::
+
+::: {.section}
+### Persistence methods[]{#Persistence_methods}
+
+Now we move onto the operations for persistence.
+
+- **getPersistenceManager(Object pc)** - returns the
+ PersistenceManager associated with the passed object (if any)
+- **makeDirty(Object pc, String fieldName)** - marks the field of the
+ passed object as dirty (meaning that it needs updating in ther
+ datastore)
+- **getObjectId(Object pc)** - returns the object identity for the
+ passed object (if persistent)
+- **getObjectIds(Collection pc)** - returns the object identities for
+ the passed objects (if persistent)
+- **getObjectIds(Object\[\] pc)** - returns the object identities for
+ the passed objects (if persistent)
+- **getVersion(Object pc)** - returns the version for the passed
+ object (if persistent)
+
+\
+:::
+
+::: {.section}
+### Lifecycle methods[]{#Lifecycle_methods}
+
+Now we move onto lifecycle operations
+
+- **getObjectState(Object pc)** - returns the object state (JDO2.1
+ JDK1.5+ only)
+- **isDirty(Object pc)** - returns whether the passed object is dirty
+- **isTransactional(Object pc)** - returns whether the passed object
+ is transactional
+- **isPersistent(Object pc)** - returns whether the passed object is
+ persistent
+- **isNew(Object pc)** - returns whether the passed object is new
+- **isDeleted(Object pc)** - returns whether the passed object is
+ deleted
+- **isDetached(Object pc)** - returns whether the passed object is
+ detached
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdoql.md b/jdoql.md
new file mode 100644
index 0000000..a1aa87c
--- /dev/null
+++ b/jdoql.md
@@ -0,0 +1,377 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDOQL'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- **JDOQL**
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDOQL[]{#JDOQL}
+---------------
+
+JDO defines ways of querying objects persisted into the datastore. It
+provides its own object-based query language (JDOQL). JDOQL is designed
+as the Java developers way of having the power of SQL queries, yet
+retaining the Java object relationship that exist in their application
+model. A typical JDOQL query may be set up in one of 2 ways. Here\'s an
+example
+
+::: {.source}
+ Declarative JDOQL :
+ Query q = pm.newQuery(mydomain.Person.class, "lastName == \"Jones\" && age < age_limit");
+ q.declareParameters("double age_limit");
+ List results = (List)q.execute(20.0);
+
+ Single-String JDOQL :
+ Query q = pm.newQuery("SELECT FROM mydomain.Person WHERE lastName == \"Jones\"" +
+ " && age < :age_limit PARAMETERS double age_limit");
+ List results = (List)q.execute(20.0);
+:::
+
+So here in our example we select all \"Person\" objects with surname of
+\"Jones\" and where the persons age is below 20. The language is
+intuitive for Java developers, and is intended as their interface to
+accessing the persisted data model. As can be seen above, the query is
+made up of distinct parts. The class being selected (the SELECT clause
+in SQL), the filter (which equates to the WHERE clause in SQL), together
+with any sorting (the ORDER BY clause in SQL), etc.
+
+Before giving details on JDOQL, you can download a quick reference guide
+[here](jdoql_quickref.pdf)
+
+\
+[]{#singlestring}
+
+::: {.section}
+### Single-String JDOQL[]{#Single-String_JDOQL}
+
+In traditional (declarative) JDOQL (JDO 1.0) it was necessary to specify
+the component parts (filter, candidate class, ordering, etc) of the
+query using the mutator methods on the Query. In JDO 2 you can now
+specify it all in a single string. This string has to follow a
+particular pattern, but provides the convenience that many people have
+been asking for. The pattern to use is as follows
+
+::: {.source}
+ SELECT [UNIQUE] [<result>] [INTO <result-class>]
+ [FROM <candidate-class> [EXCLUDE SUBCLASSES]]
+ [WHERE <filter>]
+ [VARIABLES <variable declarations>]
+ [PARAMETERS <parameter declarations>]
+ [<import declarations>]
+ [GROUP BY <grouping>]
+ [ORDER BY <ordering>]
+ [RANGE <start>, <end>]
+:::
+
+The \"keywords\" in the query are shown in UPPER CASE but can be in
+*UPPER* or *lower* case.
+
+Lets give an example of a query using this syntax
+
+::: {.source}
+ SELECT UNIQUE FROM org.datanucleus.samples.Employee ORDER BY departmentNumber
+:::
+
+so we form the parts of the query as before, yet here we just specify it
+all in a single call.
+:::
+
+::: {.section}
+### Accessing Fields[]{#Accessing_Fields}
+
+In JDOQL you access fields in the query by referring to the field name.
+For example, if you are querying a class called *Product* and it has a
+field \"price\", then you access it like this
+
+::: {.source}
+ Query query = pm.newQuery(mydomain.Product.class, "price < 150.0");
+:::
+
+In addition to the persistent fields, you can also access \"public
+static final\" fields of any class. You can do this as follows
+
+::: {.source}
+ Query query = pm.newQuery(mydomain.Product.class,
+ "taxPercent < mydomain.Product.TAX_BAND_A");
+:::
+
+So this will find all products that include a tax percentage less than
+some \"BAND A\" level. Where you are using \"public static final\"
+fields you can either fully-qualify the class name or you can include it
+in the \"imports\" section of the query (see later).
+:::
+
+::: {.section}
+### Data types : literals[]{#Data_types_:_literals}
+
+JDOQL supports the following literals: IntegerLiteral,
+FloatingPointLiteral, BooleanLiteral, CharacterLiteral, StringLiteral,
+and NullLiteral.
+:::
+
+::: {.section}
+### Operators precedence[]{#Operators_precedence}
+
+The following list describes the operator precedence in JDOQL.
+
+1. Cast
+2. Unary (\"\~\") (\"!\")
+3. Unary (\"+\") (\"-\")
+4. Multiplicative (\"\*\") (\"/\") (\"%\")
+5. Additive (\"+\") (\"-\")
+6. Relational (\"\>=\") (\"\>\") (\"\<=\") (\"\<\") (\"instanceof\")
+7. Equality (\"==\") (\"!=\")
+8. Boolean logical AND (\"&\")
+9. Boolean logical OR (\"\|\")
+10. Conditional AND (\"&&\")
+11. Conditional OR (\"\|\|\")
+:::
+
+::: {.section}
+### Concatenation Expressions[]{#Concatenation_Expressions}
+
+The concatenation operator(+) concatenates a String to either another
+String or Number. Concatenations of String or Numbers to null results in
+null.
+:::
+
+::: {.section}
+### Example 1 - Use of Explicit Parameters[]{#Example_1_-_Use_of_Explicit_Parameters}
+
+Here\'s a simple example for finding the elements of a class with a
+field below a particular threshold level. Here we pass in the threshold
+value (*limit*), and sort the output in order of ascending price.
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(mydomain.Product.class,"price < limit");
+ query.declareParameters("double limit");
+ query.setOrdering("price ascending");
+ List results = (List)query.execute(150.00);
+
+ Single-String JDOQL :
+ Query query = pm.newQuery("SELECT FROM mydomain.Product WHERE " +
+ "price < limit PARAMETERS double limit ORDER BY price ASCENDING");
+ List results = (List)query.execute(150.00);
+:::
+
+For completeness, the class is shown here
+
+::: {.source}
+ class Product
+ {
+ String name;
+ double price;
+ java.util.Date endDate;
+ ...
+ }
+
+ <jdo>
+ <package name="mydomain">
+ <class name="Product">
+ <field name="name">
+ <column length="100" jdbc-type="VARCHAR"/>
+ </field>
+ <field name="abreviation">
+ <column length="20" jdbc-type="VARCHAR"/>
+ </field>
+ <field name="price"/>
+ <field name="endDate"/>
+ </class>
+ </package>
+ </jdo>
+:::
+
+\
+:::
+
+::: {.section}
+### Example 2 - Use of Implicit Parameters[]{#Example_2_-_Use_of_Implicit_Parameters}
+
+Let\'s repeat the previous query but this time using *implicit*
+parameters.
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(mydomain.Product.class,"price < :limit");
+ query.setOrdering("price ascending");
+ List results = (List)query.execute(150.00);
+
+ Single-String JDOQL :
+ Query query = pm.newQuery("SELECT FROM mydomain.Product WHERE " +
+ "price < :limit ORDER BY price ASCENDING");
+ List results = (List)query.execute(150.00);
+:::
+
+So we omitted the declaration of the parameter and just prefixed it with
+a colon (:)
+
+\
+:::
+
+::: {.section}
+### Example 3 - Comparison against Dates[]{#Example_3_-_Comparison_against_Dates}
+
+Here\'s another example using the same Product class as above, but this
+time comparing to a Date field. Because we are using a type in our
+query, we need to *import* it \... just like you would in a Java class
+if you were using it there.
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(domain.Product.class,
+ "endDate > best_before_limit");
+ query.declareImports("import java.util.Date");
+ query.declareParameters("Date best_before_limit");
+ query.setOrdering("endDate descending");
+ Collection results = (Collection)query.execute(my_date_limit);
+
+ Single-String JDOQL :
+ Query query = pm.newQuery("SELECT FROM mydomain.Product " +
+ "WHERE endDate > best_before_limit " +
+ "PARAMETERS Date best_before_limit " +
+ "import java.util.Date ORDER BY endDate DESC");
+ List results = (List)query.execute(my_date_limit);
+:::
+
+\
+:::
+
+::: {.section}
+### Example 4 - Instanceof[]{#Example_4_-_Instanceof}
+
+This example demonstrates use of the \"instanceof\" operator. We have a
+class A that has a field \"b\" of type B and B has subclasses B1, B2,
+B3. Clearly the field \"b\" of A can be of type B, B1, B2, B3 etc, and
+we want to find all objects of type A that have the field \"b\" that is
+of type B2. We do it like this
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(mydomain.A.class);
+ query.setFilter("b instanceof mydomain.B2");
+ List results = (List)query.execute();
+
+ Single-String JDOQL :
+ Query query = pm.newQuery("SELECT FROM mydomain.A WHERE b instanceof mydomain.B2");
+ List results = (List)query.execute();
+:::
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdoql_methods.md b/jdoql_methods.md
new file mode 100644
index 0000000..5788246
--- /dev/null
+++ b/jdoql_methods.md
@@ -0,0 +1,304 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDOQL - Methods'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - **Methods**
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDOQL : Methods[]{#JDOQL_:_Methods}
+-----------------------------------
+
+When writing the \"filter\" for a JDOQL Query you can make use of some
+methods on the various Java types. The range of methods included as
+standard in JDOQL is not as flexible as with the true Java types, but
+the ones that are available are typically of much use.
+
+\
+
+::: {.section}
+### String Methods[]{#String_Methods}
+
+ Method Description
+ ------------------------- ----------------------------------------------------------------------------------------------------------------------------------
+ startsWith(String) Returns if the string starts with the passed string
+ startsWith(String, int) Returns if the string starts with the passed string, after the specified position
+ endsWith(String) Returns if the string ends with the passed string
+ indexOf(String) Returns the first position of the passed string
+ indexOf(String, int) Returns the position of the passed string, after the passed position
+ substring(int) Returns the substring starting from the passed position
+ substring(int, int) Returns the substring between the passed positions
+ toLowerCase() Returns the string in lowercase
+ toUpperCase() Retuns the string in UPPERCASE
+ matches(String pattern) Returns whether string matches the passed expression. The pattern argument follows the rules of java.lang.String.matches method.
+ trim() Retuns the string with leading/trailing spaces trimmed
+ length() Retuns the length of the string
+ charAt(int) Returns the character at the specified position of the string
+
+Here\'s an example using a Product class, looking for objects which
+their abreviation is the beginning of a trade name. The trade name is
+provided as parameter.
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(mydomain.Product.class);
+ query.setFilter(":tradeName.startsWith(this.abbreviation)");
+ List results = (List)query.execute("Workbook Advanced");
+
+ Single-String JDOQL :
+ Query query = pm.newQuery(
+ "SELECT FROM mydomain.Product " +
+ "WHERE :tradeName.startsWith(this.abbreviation)");
+ List results = (List)query.execute("Workbook Advanced");
+:::
+
+\
+
+Here\'s another example, demonstrating the \"matches\" method. Consult
+the javadocs for Java regular expressions for the syntax of the matches
+input.
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(mydomain.Product.class);
+ query.setFilter("this.abbreviation.matches(\"a*b\")");
+ List results = (List)query.execute();
+
+ Single-String JDOQL :
+ Query query = pm.newQuery(
+ "SELECT FROM mydomain.Product " +
+ "WHERE this.abbreviation.matches(\"a*b\")");
+ List results = (List)query.execute();
+:::
+
+\
+:::
+
+::: {.section}
+### Collection Methods[]{#Collection_Methods}
+
+ Method Description
+ ----------------- ------------------------------------------------------------
+ isEmpty() Returns whether the collection is empty
+ contains(value) Returns whether the collection contains the passed element
+ size() Returns the number of elements in the collection
+
+Here\'s an example demonstrating use of contains(). We have an Inventory
+class that has a Collection of Product objects, and we want to find the
+Inventory objects with 2 particular Products in it. Here we make use of
+a variable (*prd* to represent the Product being contained
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(mydomain.Inventory.class);
+ query.setFilter("products.contains(prd) && (prd.name==\"product 1\" || prd.name==\"product 2\")");
+ List results = (List)query.execute();
+
+ Single-String JDOQL:
+ Query query = pm.newQuery(
+ "SELECT FROM mydomain.Inventory EXCLUDE SUBCLASSES " +
+ "WHERE products.contains(prd) && (prd.name==\"product 1\" || prd.name==\"product 2\")");
+ List results = (List)query.execute();
+:::
+
+\
+:::
+
+::: {.section}
+### List Methods[]{#List_Methods}
+
+ Method Description
+ --------------- -----------------------------------------------------------
+ get(position) Returns the element at that position in the List (JDO3.1)
+
+\
+:::
+
+::: {.section}
+### Map Methods[]{#Map_Methods}
+
+ Method Description
+ ---------------------- ----------------------------------------------------
+ isEmpty() Returns whether the map is empty
+ containsKey(key) Returns whether the map contains the passed key
+ containsValue(value) Returns whether the map contains the passed value
+ get(key) Returns the value from the map with the passed key
+ size() Returns the number of entries in the map
+
+Here\'s an example using a Product class as a value in a Map. Our
+example represents an organisation that has several Inventories of
+products. Each Inventory of products is stored using a Map, keyed by the
+Product name. The query searches for all Inventories that contain a
+product with the name \"product 1\".
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(mydomain.Inventory.class, "products.containsKey(\"product 1\")");
+ List results = (List)query.execute();
+
+ Single-String JDOQL :
+ Query query = pm.newQuery(
+ "SELECT FROM mydomain.Inventory EXCLUDE SUBCLASSES " +
+ "WHERE products.containsKey(\"product 1\")");
+ List results = (List)query.execute();
+:::
+
+\
+:::
+
+::: {.section}
+### Temporal Methods[]{#Temporal_Methods}
+
+ Method Description
+ ------------- -------------------------------
+ getDay() Returns the day of the month
+ getMonth() Returns the month of the year
+ getYear() Returns the year
+ getHour() Returns the hour
+ getMinute() Returns the minute
+ getSecond() Returns the second
+
+\
+:::
+
+::: {.section}
+### Enum Methods[]{#Enum_Methods}
+
+ Method Description
+ ------------ -------------------------------------
+ ordinal() Returns the ordinal of the enum
+ toString() Returns the string form of the enum
+
+\
+:::
+
+::: {.section}
+### Other Methods[]{#Other_Methods}
+
+ Method Description
+ ------------------------------- -------------------------------------------------------------
+ Math.abs(number) Returns the absolute value of the passed number
+ Math.sqrt(number) Returns the square root of the passed number
+ Math.cos(number) Returns the cosine of the passed number
+ Math.sin(number) Returns the sine of the passed number
+ Math.tan(number) Returns the tangent of the passed number
+ JDOHelper.getObjectId(object) Returns the object identity of the passed persistent object
+ JDOHelper.getVersion(object) Returns the version of the passed persistent object
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdoql_result.md b/jdoql_result.md
new file mode 100644
index 0000000..684ac41
--- /dev/null
+++ b/jdoql_result.md
@@ -0,0 +1,232 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDOQL - Result'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - **Result**
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+JDOQL : Result[]{#JDOQL_:_Result}
+---------------------------------
+
+As we have seen, a JDOQL query is made up of different parts. In this
+section we look at the *result* part of the query. The result is what we
+want returning. By default (when not specifying the result) the objects
+returned will be of the candidate class type, where they match the query
+filter. Firstly let\'s look at what you can include in the *result*
+clause.
+
+- *this* - the candidate instance
+- A field name
+- A variable
+- A parameter (though why you would want a parameter returning is hard
+ to see since you input the value in the first place)
+- An aggregate (count(), avg(), sum(), min(), max())
+- An expression involving a field (e.g \"field1 + 1\")
+- A navigational expression (navigating from one field to another \...
+ e.g \"field1.field4\")
+
+The result is specified in JDOQL like this
+
+::: {.source}
+ query.setResult("count(field1), field2");
+:::
+
+In **Single-String JDOQL** you would specify it directly.
+
+\
+
+::: {.section}
+### Result type[]{#Result_type}
+
+What you specify in the *result* defines what form of result you get
+back.
+
+- **Object** - this is returned if you have only a single row in the
+ results and a single column. This is achived when you specified
+ either UNIQUE, or just an aggregate (e.g \"max(field2)\")
+- **Object\[\]** - this is returned if you have only a single row in
+ the results, but more than 1 column (e.g \"max(field1),
+ avg(field2)\")
+- **List\<Object\>** - this is returned if you have only a single
+ column in the result, and you don\'t have only aggregates in the
+ result (e.g \"field2\")
+- **List\<Object\[\]\>** - this is returned if you have more than 1
+ column in the result, and you don\'t have only aggregates in the
+ result (e.g \"field2, avg(field3)\")
+:::
+
+::: {.section}
+### Aggregates[]{#Aggregates}
+
+There are situations when you want to return a single number for a
+column, representing an aggregate of the values of all records. There
+are 5 standard JDO2 aggregate functions available. These are
+
+- **avg(val)** - returns the average of \"val\". \"val\" can be a
+ field, numeric field expression or \"distinct field\".
+- **sum(val)** - returns the sum of \"val\". \"val\" can be a field,
+ numeric field expression, or \"distinct field\".
+- **count(val)** - returns the count of records of \"val\". \"val\"
+ can be a field, or can be \"this\", or \"distinct field\".
+- **min(val)** - returns the minimum of \"val\". \"val\" can be a
+ field
+- **max(val)** - returns the maximum of \"val\". \"val\" can be a
+ field
+
+So to utilise these you could specify something like
+
+::: {.source}
+ Query q = pm.newQuery("SELECT max(price), min(price) FROM mydomain.Product WHERE status == 1");
+:::
+
+This will return a single row of results with 2 values, the maximum
+price and the minimum price of all products that have status code of 1.
+
+\
+:::
+
+::: {.section}
+### Example - Use of aggregates[]{#Example_-_Use_of_aggregates}
+
+JDO 2 introduces the ability to use aggregates in queries. Here\'s
+another example using the same Product class as above, but this time
+looking for the maximum price of products that are CD Players. Note that
+the result for this particular query will be of type Double since there
+is a single double precision value being returned via the \"result\".
+
+::: {.source}
+ Declarative JDOQL :
+ Query query = pm.newQuery(mydomain.Product.class);
+ query.setFilter("name == \"CD Player\"");
+ query.setResult("max(this.price)");
+ List results = (List)query.execute();
+ Iterator iter = c.iterator();
+ Double max_price = (Double)iter.next();
+
+ Single-String JDOQL :
+ Query query = pm.newQuery("SELECT max(price) FROM mydomain.Product WHERE name == \"CD Player\"");
+ List results = (List)query.execute();
+ Iterator iter = c.iterator();
+ Double max_price = (Double)iter.next();
+:::
+
+\
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/jdoquery_dtd.md b/jdoquery_dtd.md
new file mode 100644
index 0000000..86787b6
--- /dev/null
+++ b/jdoquery_dtd.md
@@ -0,0 +1,169 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDOQuery DTD'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+ - [Annotations](annotations.html "Annotations")
+ - [jdo DTD/XSD](jdo_dtd.html "jdo DTD/XSD")
+ - [orm DTD/XSD](orm_dtd.html "orm DTD/XSD")
+ - **jdoquery DTD/XSD**
+ - [jdoconfig DTD/XSD](jdoconfig_dtd.html "jdoconfig DTD/XSD")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Meta-Data - JDOQuery[]{#Meta-Data_-_JDOQuery}
+---------------------------------------------
+
+JDO defines XML MetaData in **jdo** files as well as **orm** files, but
+also specifies that named queries can be defined in *jdoquery* files. As
+always with XML, the metadata must match the defined DTD/XSD for that
+file type. This section describes the content of the **jdoquery** files.
+All **jdoquery** files must contain a valid DTD/DOCTYPE specification.
+You can use PUBLIC or SYSTEM versions of these.
+
+Here are a few examples valid for **jdoquery** files eith DTD
+specification
+
+::: {.source}
+ <!DOCTYPE jdoquery PUBLIC
+ "-//Sun Microsystems, Inc.//DTD Java Data Objects Query Metadata 3.0//EN"
+ "http://xmlns.jcp.org/dtd/jdoquery_3_0.dtd">
+
+ <!DOCTYPE jdoquery SYSTEM "file:/javax/jdo/jdoquery.dtd">
+:::
+
+\
+
+Here is an example valid for **jdoquery** files with XSD specification
+
+::: {.source}
+ <?xml version="1.0" encoding="UTF-8" ?>
+ <jdo xmlns="http://xmlns.jcp.org/xml/ns/jdo/jdo"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/jdo/jdoquery
+ http://xmlns.jcp.org/xml/ns/jdo/jdoquery_3_0.xsd">
+ ...
+ </jdo>
+:::
+
+Your MetaData should match either the
+[DTD](http://xmlns.jcp.org/dtd/jdoquery_3_0.dtd){.externalLink} or the
+[XSD](http://xmlns.jcp.org/xml/ns/jdo/jdoquery_3_0.xsd){.externalLink}
+specification.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/mail-lists.md b/mail-lists.md
new file mode 100644
index 0000000..201ebc3
--- /dev/null
+++ b/mail-lists.md
@@ -0,0 +1,159 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - Mailing Lists'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- **Mailing Lists**
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Apache JDO Mailing Lists[]{#Apache_JDO_Mailing_Lists}
+-----------------------------------------------------
+
+There are several publicly available mailing lists for JDO. The user
+list is for general discussion of the Apache JDO project and JDO
+technology. The dev list is for internal discussion among the JDO
+developers. It is open to the public if you are interested in seeing how
+the sausage is made. For those dedicated to the project who want to
+follow its development even more closely there\'s the commits mailing
+list!
+
++-----------------+-----------------+-----------------+-----------------+
+| **User List** : | [Subscribe](mai | [Unsubscribe](m | [Archive](http: |
+| <jdo-user@db.ap | lto:jdo-user-su | ailto:jdo-user- | //mail-archives |
+| ache.org> | bscribe@db.apac | unsubscribe@db. | .apache.org/mod |
+| | he.org){.extern | apache.org){.ex | _mbox/db-jdo-us |
+| | al} | ternal} | er/){.externalL |
+| | | | ink} |
++-----------------+-----------------+-----------------+-----------------+
+| **Dev List** : | [Subscribe](mai | [Unsubscribe](m | [Archive](http: |
+| <jdo-dev@db.apa | lto:jdo-dev-sub | ailto:jdo-dev-u | //mail-archives |
+| che.org> | scribe@db.apach | nsubscribe@db.a | .apache.org/mod |
+| | e.org){.externa | pache.org){.ext | _mbox/db-jdo-de |
+| | l} | ernal} | v/){.externalLi |
+| | | | nk} |
++-----------------+-----------------+-----------------+-----------------+
+| **Commits | [Subscribe](mai | [Unsubscribe](m | [Archive](http: |
+| List** : | lto:jdo-commits | ailto:jdo-commi | //mail-archives |
+| <jdo-commits@db | -subscribe@db.a | ts-unsubscribe@ | .apache.org/mod |
+| .apache.org> | pache.org){.ext | db.apache.org){ | _mbox/db-jdo-co |
+| | ernal} | .external} | mmits/){.extern |
+| | | | alLink} |
++-----------------+-----------------+-----------------+-----------------+
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/metadata.md b/metadata.md
new file mode 100644
index 0000000..c4caa51
--- /dev/null
+++ b/metadata.md
@@ -0,0 +1,184 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO MetaData'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- **MetaData**
+ - [Annotations](annotations.html "Annotations")
+ - [jdo DTD/XSD](jdo_dtd.html "jdo DTD/XSD")
+ - [orm DTD/XSD](orm_dtd.html "orm DTD/XSD")
+ - [jdoquery DTD/XSD](jdoquery_dtd.html "jdoquery DTD/XSD")
+ - [jdoconfig DTD/XSD](jdoconfig_dtd.html "jdoconfig DTD/XSD")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Persistence MetaData[]{#Persistence_MetaData}
+---------------------------------------------
+
+JDO 1.0 and JDO 2.0 support specification of persistence using XML
+MetaData. JDO 2.1 adds on the ability to specify persistence using Java5
+annotations.
+
+::: {.section}
+### XML MetaData[]{#XML_MetaData}
+
+JDO expects any XML MetaData to be specified in a file or files in
+particular positions in the file system. For example, if you have a
+class *com.mycompany.sample.MyExample*, JDO will look for any of the
+following files until it finds one (in the order stated) :-
+
+::: {.source}
+ META-INF/package.jdo
+ WEB-INF/package.jdo
+ package.jdo
+ com/package.jdo
+ com/mycompany/package.jdo
+ com/mycompany/sample/package.jdo
+ com/mycompany/sample/MyExample.jdo
+:::
+
+In addition to specifying XML MetaData in a **jdo** file, if defining
+O/R mapping information you can also split this out into an ORM file.
+The locations for ORM files are similar in nature to those for JDO
+files.
+
+::: {.source}
+ META-INF/package-{mapping}.orm
+ WEB-INF/package-{mapping}.orm
+ package-{mapping}.orm
+ com/package-{mapping}.orm
+ com/mycompany/package-{mapping}.orm
+ com/mycompany/sample/package-{mapping}.orm
+ com/mycompany/sample/MyExample-{mapping}.orm
+:::
+
+where *{mapping}* is a property specified by the user and may be
+\"mysql\" for ORM information for MySQL datastores, and \"oracle\" for
+ORM information for Oracle datastores, and so on.
+
+\
+:::
+
+::: {.section}
+### Annotations[]{#Annotations}
+
+JDO 2.1 provides support for annotations. Classes and fields/properties
+can be annotated defining the persistence and, optionally, any ORM
+information.
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/newshistory.md b/newshistory.md
new file mode 100644
index 0000000..092d527
--- /dev/null
+++ b/newshistory.md
@@ -0,0 +1,138 @@
+---
+Date-Revision-yyyymmdd: 20150918
+author: JDO Documentation Team
+lang: en
+title: 'JDO - News'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Older JDO News[]{#Older_JDO_News}
+---------------------------------
+
+**JDO code donated to Apache by Sun Microsystems, Inc.**
+
+On 9-Mar-2005 Sun Microsystems, Inc. officially donated to Apache
+Software Foundation the intellectual property known as Java Data
+Objects, v. 1.0.2 and successors thereto to the extent provided by Sun.
+
+This was accomplished via Schedule B-2 to the Software Grant and
+Corporate Contributor License Agreement (CCLA) between The Apache
+Software Foundation and Sun Microsystems, Inc.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/object_retrieval.md b/object_retrieval.md
new file mode 100644
index 0000000..6d6e853
--- /dev/null
+++ b/object_retrieval.md
@@ -0,0 +1,199 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - JDO Object Retrieval'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- **Object Retrieval**
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Object Retrieval[]{#Object_Retrieval}
+-------------------------------------
+
+JDO provides persistence of objects. The logical next step after
+persisting objects is to retrieve them for use in your application.
+There are several ways to do this
+
+::: {.section}
+### Retrieve an object from its identity[]{#Retrieve_an_object_from_its_identity}
+
+The simplest form of object retrieval is where we have the identity.
+This is simply
+
+::: {.source}
+ Object obj = pm.getObjectById(identity);
+
+:::
+
+If the object is in the JDO cache then it is retrieved from there,
+otherwise the JDO implementation goes to the datastore. When the object
+is retrieved its fields are populated according to its Fetch Group.
+:::
+
+::: {.section}
+### Retrieve an object based on its Extent[]{#Retrieve_an_object_based_on_its_Extent}
+
+A persistable class can be persisted with an **Extent** of all instances
+of that type. You can use this to retrieve objects of the required type,
+like this
+
+::: {.source}
+ Extent ex = pm.getExtent(MyClass.class, true);
+ Iterator iter = ex.iterator();
+ while (iter.hasNext())
+ {
+ MyClass obj = (MyClass)iter.next();
+ ...
+ }
+:::
+
+The second argument in the *getExtent* call is whether to include
+instances of subclasses.
+
+\
+:::
+
+::: {.section}
+### Retrieve an object based on a criteria[]{#Retrieve_an_object_based_on_a_criteria}
+
+Where we want to retrieve all objects based on some criteria (e.g all
+objects of class A where field \'x\' of A is a certain value) we need to
+use a query language. JDO2 provides 2 options here. JDOQL is
+object-based and allows you to express your query in terms of the
+classes and fields you are using. SQL is datastore-based and allows you
+to express your query in terms of the datastore tables and columns.
+
+To give an example of a JDOQL query
+
+::: {.source}
+ Query q = pm.newQuery(MyClass.class, "field1 < value");
+ q.declareParameters("int value");
+ List results = q.execute(205);
+ Iterator iter = results.iterator();
+ while (iter.hasNext())
+ {
+ MyClass obj = (MyClass)iter.next();
+ }
+:::
+
+If the objects found by the query are in the JDO cache then they are
+retrieved from there, otherwise the JDO implementation goes to the
+datastore. When the objects are retrieved their fields are populated
+according to the Fetch Group.
+:::
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/orm_dtd.md b/orm_dtd.md
new file mode 100644
index 0000000..f5d8698
--- /dev/null
+++ b/orm_dtd.md
@@ -0,0 +1,169 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - ORM DTD'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+ - [Annotations](annotations.html "Annotations")
+ - [jdo DTD/XSD](jdo_dtd.html "jdo DTD/XSD")
+ - **orm DTD/XSD**
+ - [jdoquery DTD/XSD](jdoquery_dtd.html "jdoquery DTD/XSD")
+ - [jdoconfig DTD/XSD](jdoconfig_dtd.html "jdoconfig DTD/XSD")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- [PersistenceManager](pm.html "PersistenceManager")
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
+:::
+:::
+
+::: {#bodyColumn}
+::: {#contentBox}
+::: {.section}
+Meta-Data - ORM[]{#Meta-Data_-_ORM}
+-----------------------------------
+
+JDO defines XML MetaData in **jdo** files as well as **orm** files. As
+always with XML, the metadata must match the defined DTD/XSD for that
+file type. This section describes the content of the **orm** files. The
+content of **jdo** files can be found [here](jdo_dtd.html). All **orm**
+files must contain a valid DTD/DOCTYPE specification. You can use PUBLIC
+or SYSTEM versions of these.
+
+Here are a couple of examples valid for **orm** files with DTD
+specification
+
+::: {.source}
+ <!DOCTYPE orm PUBLIC
+ "-//Sun Microsystems, Inc.//DTD Java Data Objects Mapping Metadata 3.0//EN"
+ "http://xmlns.jcp.org/dtd/orm_3_0.dtd">
+
+ <!DOCTYPE orm SYSTEM "file:/javax/jdo/orm.dtd">
+:::
+
+\
+
+Here is an example valid for **orm** files with XSD specification
+
+::: {.source}
+ <?xml version="1.0" encoding="UTF-8" ?>
+ <orm xmlns="http://xmlns.jcp.org/xml/ns/jdo/orm"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/jdo/orm
+ http://xmlns.jcp.org/xml/ns/jdo/orm_3_0.xsd">
+ ...
+ </orm>
+:::
+
+Your MetaData should match either the
+[DTD](http://xmlns.jcp.org/dtd/orm_3_0.dtd){.externalLink} or the
+[XSD](http://xmlns.jcp.org/xml/ns/jdo/orm_3_0.xsd){.externalLink}
+specification.
+:::
+:::
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+
+::: {#footer}
+::: {.xright}
+Copyright © 2005-2015. All Rights Reserved.
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
diff --git a/pm.md b/pm.md
new file mode 100644
index 0000000..faf1ade
--- /dev/null
+++ b/pm.md
@@ -0,0 +1,347 @@
+---
+Date-Revision-yyyymmdd: 20150918
+lang: en
+title: 'JDO - Persistence Manager'
+---
+
+::: {#banner}
+[](./){#bannerLeft} [](./){#bannerRight}
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#breadcrumbs}
+::: {.xright}
+[Facebook](https://www.facebook.com/JavaDataObjects "Facebook"){.externalLink}
+\|
+[Twitter](https://twitter.com/JavaDataObjects "Twitter"){.externalLink}
+\|
+[Google+](https://plus.google.com/106584233526334524963 "Google+"){.externalLink}
+\| [Wiki](http://wiki.apache.org/jdo "Wiki"){.externalLink} \| [Issue
+Tracker](http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10630 "Issue Tracker"){.externalLink}
+\| [Mailing Lists](mail-lists.html "Mailing Lists") \| [Latest
+Javadocs](api30/apidocs/index.html "Latest Javadocs")
+:::
+
+::: {.clear}
+
+------------------------------------------------------------------------
+:::
+:::
+
+::: {#leftColumn}
+::: {#navcolumn}
+##### General
+
+- [Home](index.html "Home")
+- [Why JDO?](why_jdo.html "Why JDO?")
+- [JDO v JPA](jdo_v_jpa.html "JDO v JPA")
+- [JDO v JPA : API](jdo_v_jpa_api.html "JDO v JPA : API")
+- [JDO v JPA : ORM](jdo_v_jpa_orm.html "JDO v JPA : ORM")
+- [Downloads](downloads.html "Downloads")
+- [License](http://www.apache.org/licenses/LICENSE-2.0 "License"){.externalLink}
+
+##### JDO Implementation
+
+- [Specifications](specifications.html "Specifications")
+- [TCK](tck.html "TCK")
+
+##### JDO Usage
+
+- [Implementations](impls.html "Implementations")
+- [API Javadoc](javadoc.html "API Javadoc")
+- [Types of Classes](class_types.html "Types of Classes")
+- [Types of Fields](field_types.html "Types of Fields")
+- [MetaData](metadata.html "MetaData")
+- [Bytecode Enhancement](enhancement.html "Bytecode Enhancement")
+- [JDOHelper](jdohelper.html "JDOHelper")
+- [PersistenceManagerFactory](pmf.html "PersistenceManagerFactory")
+- **PersistenceManager**
+- [Transactions](transactions.html "Transactions")
+- [Attach-Detach](attach_detach.html "Attach-Detach")
+- [Fetch Groups](fetchgroups.html "Fetch Groups")
+- [Object States](state_transition.html "Object States")
+- [Object Retrieval](object_retrieval.html "Object Retrieval")
+- [JDOQL](jdoql.html "JDOQL")
+ - [Result](jdoql_result.html "Result")
+ - [Methods](jdoql_methods.html "Methods")
+ - [Quick Ref PDF](jdoql_quickref.pdf "Quick Ref PDF")
+- [Extents](extents.html "Extents")
+- [Guides](guides.html "Guides")
+- [References](references.html "References")
+- [Exceptions](exceptions.html "Exceptions")
+- [Glossary](glossary.html "Glossary")
+
+##### Articles
+
+- [JDO 3.0 Overview](jdo_3_0_overview.html "JDO 3.0 Overview")
+
+##### Community
+
+- [Get Involved](get-involved.html "Get Involved")
+- [Project Team](team-list.html "Project Team")
+- [Mailing Lists](mail-lists.html "Mailing Lists")
+- [FAQ](faq.html "FAQ")
+
+##### Development
+
+- [RoadMap / TODO](roadmap.html "RoadMap / TODO")
+- [Source Code](svn.html "Source Code")
+- [Coding
+ Standards](http://cwiki.apache.org/GMOxDEV/coding-standards.html "Coding Standards"){.externalLink}
+- [Issue Tracking](issuetracking.html "Issue Tracking")
+- [Dependencies](dependencies.html "Dependencies")
+
+[{.poweredBy}](http://maven.apache.org/ "Built by Maven"){.poweredBy}
... 2638 lines suppressed ...