anchor.diff:      @GeneratedValue(strategy = GenerationType.IDENTITY)
       @Type(type = "objectid")
       private String id;
  +
       private String title;
   
  -    //getters, setters ...
  +    // getters, setters ...
   }
   ----
   
  
positive.code: 
  http://www.mongodb.org[MongoDB] is a document oriented datastore
  written in C++ with strong emphasis on ease of use.
  
  ==== Configuring MongoDB
  
  This implementation is based upon the MongoDB Java driver.
  The currently supported version is {mongodb-version}.
  
  The following properties are available to configure MongoDB support:
  
  
negative.code: ----
  {
      "_id" : { "owners_id" : "owner0001" },
      "rows" : [ "accountABC", "accountXYZ" ]
  }
  {
      "_id" : { "bankAccounts_id" : "accountXYZ" },
      "rows" : [ "owner0001" ]
  }
  ----
  ====
  
  [NOTE]
  ====
  This strategy won't affect *-to-one associations or embedded collections.
  ====
  
  .Unidirectional one-to-many using one collection per strategy
  ====
  [source, JAVA]
  ----
  @Entity
  public class Basket {
  
      @Id
      private String id;
  
      private String owner;
  
      @OneToMany
      private List<Product> products = new ArrayList<Product>();
  
      // getters, setters ...
  }
  
  @Entity
  public class Product {
  
      @Id
      private String name;
  
      private String description;
  
      // getters, setters ...
  }
  ----
  
  Basket collection
  
  [source, JSON]
  ----
  {
    "_id" : "davide_basket",
    "owner" : "Davide"
  }
  ----
  
  Product collection
  [source, JSON]
  ----
  {
    "_id" : "Pretzel",
    "description" : "Glutino Pretzel Sticks"
  }
  {
    "_id" : "Beer",
    "description" : "Tactical nuclear penguin"
  }
  ----
  
  associations_Basket_Product collection
  [source, JSON]
  ----
  {
    "_id" : { "Basket_id" : "davide_basket" },
    "rows" : [ "Beer", "Pretzel" ]
  }
  ----
  ====
  
  The order of the element in the list might be preserved using @OrderColumn.
  Hibernate OGM will store the order adding an additional fieldd to the document
  containing the association.
  
  .Unidirectional one-to-many using one collection per strategy with @OrderColumn
  ====
  [source, JAVA]
  ----
  @Entity
  public class Basket {
  
      @Id
      private String id;
  
      private String owner;
  
      @OneToMany
      @OrderColumn
      private List<Product> products = new ArrayList<Product>();
  
      // getters, setters ...
  }
  
  @Entity
  public class Product {
  
      @Id
      private String name;
  
      private String description;
  
      // getters, setters ...
  }
  ----
  
  Basket collection
  
  [source, JSON]
  ----
  {
    "_id" : "davide_basket",
    "owner" : "Davide"
  }
  ----
  
  Product collection
  
  [source, JSON]
  ----
  {
    "_id" : "Pretzel",
    "description" : "Glutino Pretzel Sticks"
  }
  {
    "_id" : "Beer",
    "description" : "Tactical nuclear penguin"
  }
  ----
  
  associations_Basket_Product collection
  
  [source, JSON]
  ----
  {
    "_id" : { "Basket_id" : "davide_basket" },
    "rows" : [
      {
        "products_name" : "Pretzel",
        "products_ORDER" : 1
      },
      {
        "products_name" : "Beer",
        "products_ORDER" : 0
      }
    ]
  }
  ----
  ====
  
  .Unidirectional many-to-many using one collection per association strategy
  ====
  [source, JAVA]
  ----
  @Entity
  public class Student {
  
      @Id
      private String id;
      private String name;
  
      // getters, setters ...
  }
  
  @Entity
  public class ClassRoom {
  
      @Id
      private long id;
      private String lesson;
  
      @ManyToMany
      private List<Student> students = new ArrayList<Student>();
  
      // getters, setters ...
  }
  ----
  
  Student collection
  
  [source, JSON]
  ----
  {
    "_id" : "john",
    "name" : "John Doe"
  }
  {
    "_id" : "mario",
    "name" : "Mario Rossi"
  }
  {
    "_id" : "kate",
    "name" : "Kate Doe"
  }
  ----
  
  ClassRoom collection
  
  [source, JSON]
  ----
  {
    "_id" : NumberLong(1),
    "lesson" : "Math"
  }
  {
    "_id" : NumberLong(2),
    "lesson" : "English"
  }
  ----
  
  associations_ClassRoom_Student
  
  [source, JSON]
  ----
  {
    "_id" : {
      "ClassRoom_id" : NumberLong(1),
    },
    "rows" : [ "john", "mario" ]
  }
  {
    "_id" : {
      "ClassRoom_id" : NumberLong(2),
    },
    "rows" : [ "mario", "kate" ]
  }
  ----
  ====
  
  .Bidirectional many-to-many using one collection per association strategy
  ====
  [source, JAVA]
  ----
  @Entity
  public class AccountOwner {
  
      @Id
      private String id;
  
      private String SSN;
  
      @ManyToMany
      private Set<BankAccount> bankAccounts;
  
      // getters, setters ...
  }
  
  @Entity
  public class BankAccount {
  
      @Id
      private String id;
  
      private String accountNumber;
  
      @ManyToMany(mappedBy = "bankAccounts")
      private Set<AccountOwner> owners = new HashSet<AccountOwner>();
  
      // getters, setters ...
  }
  ----
  
  AccountOwner collection
  
  [source, JSON]
  ----
  {
    "_id" : "owner_1",
    "SSN" : "0123456"
  }
  ----
  
  BankAccount collection
  
  [source, JSON]
  ----
  {
    "_id" : "account_1",
    "accountNumber" : "X2345000"
  }
  ----
  
  associations_AccountOwner_BankAccount collection 
  
  [source, JSON]
  ----
  {
    "_id" : {
      "bankAccounts_id" : "account_1"
    },
    "rows" : [ "owner_1" ] 
  }
  {
    "_id" : {
      "owners_id" : "owner_1"
    },
    "rows" : [ "account_1" ]
  }
  ----
  ====
  
  [[mongodb-one-collection-strategy-join-table]]
  You can change the name of the collection containing the association using the +@JoinTable+ annotation.
  In the following example, the name of the collection containing the association is +OwnerBankAccounts+
  (instead of the default +associations_AccountOwner_BankAccount+)
  
  .Bidirectional many-to-many using one collection per association strategy and @JoinTable
  ====
  [source, JAVA]
  ----
  @Entity
  public class AccountOwner {
  
      @Id
      private String id;
  
      private String SSN;
  
      @ManyToMany
      @JoinTable( name = "OwnerBankAccounts" )
      private Set<BankAccount> bankAccounts;
  
      // getters, setters ...
  }
  
  @Entity
  public class BankAccount {
  
      @Id
      private String id;
  
      private String accountNumber;
  
      @ManyToMany(mappedBy = "bankAccounts")
      private Set<AccountOwner> owners = new HashSet<AccountOwner>();
  
      // getters, setters ...
  }
  ----
  
  AccountOwner collection
  
  [source, JSON]
  ----
  {
    "_id" : "owner_1",
    "SSN" : "0123456"
  }
  ----
  
  BankAccount collection
  
  [source, JSON]
  ----
  {
    "_id" : "account_1",
    "accountNumber" : "X2345000"
  }
  ----
  
  OwnerBankAccount
  
  [source, JSON]
  ----
  {
    "_id" : {
      "bankAccounts_id" : "account_1"
    },
    "rows" : [ "owner_1" ] 
  }
  {
    "_id" : {
      "owners_id" : "owner_1"
    },
    "rows" : [ "account_1" ]
  }
  ----
  ====
  
  [[mongodb-association-document-strategy]]
  ====== Global collection strategy
  
  With this strategy, Hibernate OGM creates a single collection named +Associations+
  in which it will store all navigation information for all associations.
  Each document of this collection is structured in 2 parts.
  The first is the +_id+ field which contains the identifier information
  of the association owner and the name of the association table.
  The second part is the +rows+ field which stores (into an embedded collection) all ids
  that the current instance is related to.
  
  [NOTE]
  ====
  This strategy won't affect *-to-one associations or embedded collections.
  
  Generally, you should not make use of this strategy 
  unless embedding the association information proves to be too big for your document
  and you wish to separate them.
  ====
  
  .Associations collection containing unidirecational association
  ====
  [source, JSON]
  ----
  {
      "_id": {
          "owners_id": "owner0001",
          "table": "AccountOwner_BankAccount"
      },
      "rows": [ "accountABC", "accountXYZ" ]
  }
  ----
  ====
  
  For a bidirectional relationship, another document is created where ids are reversed.
  Don't worry, Hibernate OGM takes care of keeping them in sync:
  
  .Associations collection containing a bidirectional association
  ====
  [source, JSON]
  ----
  {
      "_id": {
          "owners_id": "owner0001",
          "table": "AccountOwner_BankAccount"
      },
      "rows": [ "accountABC", "accountXYZ" ]
  }
  {
      "_id": {
          "bankAccounts_id": "accountXYZ",
          "table": "AccountOwner_BankAccount"
      },
      "rows": [ "owner0001" ]
  }
  ----
  ====
  
  .Unidirectional one-to-many using global collection strategy
  ====
  [source, JAVA]
  ----
  @Entity
  public class Basket {
  
      @Id
      private String id;
  
      private String owner;
  
      @OneToMany
      private List<Product> products = new ArrayList<Product>();
  
      // getters, setters ...
  }
  
  @Entity
  public class Product {
  
      @Id
      private String name;
  
      private String description;
  
      // getters, setters ...
  }
  ----
  
  Basket collection
  
  [source, JSON]
  ----
  {
    "_id" : "davide_basket",
    "owner" : "Davide"
  }
  ----
  
  Product collection
  [source, JSON]
  ----
  {
    "_id" : "Pretzel",
    "description" : "Glutino Pretzel Sticks"
  }
  {
    "_id" : "Beer",
    "description" : "Tactical nuclear penguin"
  }
  ----
  
  Associations collection
  [source, JSON]
  ----
  {
    "_id" : {
      "Basket_id" : "davide_basket",
      "table" : "Basket_Product"
    },
    "rows" : [
      {
        "products_name" : "Pretzel",
        "products_ORDER" : 1
      },
      {
        "products_name" : "Beer",
      "products_ORDER" : 0
      }
    ]
  }
  ----
  ====
  
  .Unidirectional one-to-many using global collection strategy with +@JoinTable+
  ====
  [source, JAVA]
  ----
  @Entity
  public class Basket {
  
      @Id
      private String id;
  
      private String owner;
  
      @OneToMany
      // It will change the value stored in the field table in the Associations collection
      @JoinTable( name = "BasketContent" )
      private List<Product> products = new ArrayList<Product>();
  
      // getters, setters ...
  }
  
  @Entity
  public class Product {
  
      @Id
      private String name;
  
      private String description;
  
      // getters, setters ...
  }
  ----
  
  Basket collection
  
  [source, JSON]
  ----
  {
    "_id" : "davide_basket",
    "owner" : "Davide"
  }
  ----
  
  Product collection
  [source, JSON]
  ----
  {
    "_id" : "Pretzel",
    "description" : "Glutino Pretzel Sticks"
  }
  {
    "_id" : "Beer",
    "description" : "Tactical nuclear penguin"
  }
  ----
  
  Associations collection
  
  [source, JSON]
  ----
  {
    "_id" : {
      "Basket_id" : "davide_basket",
      "table" : "BasketContent"
    },
    "rows" : [ "Beer", "Pretzel" ]
  }
  ----
  ====
  
  .Unidirectional many-to-many using global collection strategy
  ====
  [source, JAVA]
  ----
  @Entity
  public class Student {
  
      @Id
      private String id;
      private String name;
  
      // getters, setters ...
  }
  
  @Entity
  public class ClassRoom {
  
      @Id
      private long id;
      private String lesson;
  
      @ManyToMany
      private List<Student> students = new ArrayList<Student>();
  
      // getters, setters ...
  }
  ----
  
  Student collection
  
  [source, JSON]
  ----
  {
    "_id" : "john",
    "name" : "John Doe"
  }
  {
    "_id" : "mario",
    "name" : "Mario Rossi"
  }
  {
    "_id" : "kate",
    "name" : "Kate Doe"
  }
  ----
  
  ClassRoom collection
  
  [source, JSON]
  ----
  {
    "_id" : NumberLong(1),
    "lesson" : "Math"
  }
  {
    "_id" : NumberLong(2),
    "lesson" : "English"
  }
  ----
  
  Associations collection
  
  [source, JSON]
  ----
  {
    "_id" : {
      "ClassRoom_id" : NumberLong(1),
      "table" : "ClassRoom_Student"
    },
    "rows" : [ "john", "mario" ]
  }
  {
    "_id" : {
      "ClassRoom_id" : NumberLong(2),
      "table" : "ClassRoom_Student"
    },
    "rows" : [ "mario", "kate" ]
  }
  ----
  ====
  
  .Bidirectional many-to-many using global collection strategy
  ====
  [source, JAVA]
  ----
  @Entity
  public class AccountOwner {
  
      @Id
      private String id;
  
      private String SSN;
  
      @ManyToMany
      private Set<BankAccount> bankAccounts;
  
      // getters, setters ...
  }
  
  @Entity
  public class BankAccount {
  
      @Id
      private String id;
  
      private String accountNumber;
  
      @ManyToMany(mappedBy = "bankAccounts")
      private Set<AccountOwner> owners = new HashSet<AccountOwner>();
  
      // getters, setters ...
  }
  ----
  
  AccountOwner collection
  
  [source, JSON]
  ----
  {
    "_id" : "owner0001",
    "SSN" : "0123456"
  }
  ----
  
  BankAccount collection
  
  [source, JSON]
  ----
  {
    "_id" : "account_1",
    "accountNumber" : "X2345000"
  }
  ----
  
  Associations collection
  
  [source, JSON]
  ----
  {
    "_id" : {
      "bankAccounts_id" : "account_1",
      "table" : "AccountOwner_BankAccount"
      },
  
    "rows" : [ "owner0001" ]
  }
  {
    "_id" : {
      "owners_id" : "owner0001",
      "table" : "AccountOwner_BankAccount"
    },
  
    "rows" : [ "account_1" ]
  }
  ----
  ====
  
  
  ==== Transactions
  
  