DocumentEntity entity = DocumentEntity.of("collection");

Document diana = Document.of("name", "Diana");

entity.add(diana);

List<DocumentEntity> entities = Collections.singletonList(entity);

DocumentCollectionManager manager = // instance;

// Insert operations
manager.insert(entity);

manager.insert(entity, Duration.ofHours(2L)); // inserts with two hours of TTL

manager.insert(entities, Duration.ofHours(2L)); // inserts with two hours of TTL

// Update operations
manager.update(entity);

manager.update(entities);

DocumentQuery query = DocumentQuery.select().from("Person").build();
//static imports
DocumentQuery query = select().from("Person").build();

DocumentQuery query = DocumentQuery.builder().from("Person").build();
//static imports
DocumentQuery query = builder().from("Person").build();

 DocumentQuery query = DocumentQuery.select()
                .from("Person").where("name").eq("Ada Lovelace")
                .build();
//static imports
 DocumentQuery query = select()
                .from("Person").where("name").eq("Ada Lovelace")
                .build();

DocumentQuery query = DocumentQuery.builder()
                .from("Person").where(DocumentCondition.eq("name", "Ada Lovelace"))
                .build();
//static imports
DocumentQuery query = builder().from("Person")
                               .where(eq("name", "Ada Lovelace"))
                               .build();

  DocumentQuery query = DocumentQuery.select("name")
                .from("Person").where("name").eq("Ada Lovelace")
                .build();
//static imports
  DocumentQuery query = select("name")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .build();

  DocumentQuery query = DocumentQuery.builder("name")
                .from("Person").where(DocumentCondition.eq("name", "Ada Lovelace"))
                .build();
//static imports

  DocumentQuery query = builder("name")
                .from("Person").where(eq("name", "Ada Lovelace"))
                .build();

DocumentQuery query = DocumentQuery.select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .and("age").gt(20)
                .build();
//static imports
DocumentQuery query = select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .and("age").gt(20)
                .build();

DocumentQuery query = DocumentQuery.builder("name", "age")
             .from("Person")
             .where(DocumentCondition.and(DocumentCondition.eq("name", "Ada Lovelace"),
             DocumentCondition.gt("age", 20)))
             .build();

//static imports

DocumentQuery query = builder("name", "age")
             .from("Person")
             .where(and(eq("name", "Ada Lovelace"),
             gt("age", 20)))
             .build();

  DocumentQuery query = DocumentQuery.select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .or("age").gt(20)
                .build();
//static imports
  DocumentQuery query = select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .or("age").gt(20)
                .build();

DocumentQuery query = DocumentQuery.builder("name", "age")
             .from("Person")
             .where(DocumentCondition.or(DocumentCondition.eq("name", "Ada Lovelace"),
             DocumentCondition.gt("age", 20)))
             .build();

//static imports

DocumentQuery query = builder("name", "age")
             .from("Person")
             .where(or(eq("name", "Ada Lovelace"),
             gt("age", 20)))
             .build();

DocumentQuery query = DocumentQuery.select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .or("age").gt(20)
                .skip(1)
                .limit(2)
                .build();
//static imports
DocumentQuery query = select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .or("age").gt(20)
                .skip(1)
                .limit(2)
                .build();

DocumentQuery query = DocumentQuery.builder("name", "age")
                .from("Person")
                .where(DocumentCondition.or(DocumentCondition.eq("name", "Ada Lovelace"),
                        DocumentCondition.gt("age", 20)))
                .skip(1).limit(2)
                .build();

//static imports

DocumentQuery query = builder("name", "age")
                .from("Person")
                .where(or(eq("name", "Ada Lovelace"),
                        gt("age", 20)))
                .skip(1).limit(2)
                .build();

DocumentQuery query = DocumentQuery.select("name", "age")
            .from("Person")
            .where("name").eq("Ada Lovelace")
            .or("age").gt(20)
            .orderBy("name").asc()
            .orderBy("desc").desc()
            .build();

//static imports

DocumentQuery query = select("name", "age")
            .from("Person")
            .where("name").eq("Ada Lovelace")
            .or("age").gt(20)
            .orderBy("name").asc()
            .orderBy("desc").desc()
            .build();

 DocumentQuery query = DocumentQuery.builder("name", "age")
         .from("Person")
         .where(DocumentCondition.or(DocumentCondition.eq("name", "Ada Lovelace"),
                DocumentCondition.gt("age", 20)))
         .sort(Sort.asc("name"), Sort.desc("age"))
         .build();

//static imports

DocumentQuery query = builder("name", "age")
         .from("Person")
         .where(or(eq("name", "Ada Lovelace"),
                gt("age", 20)))
         .sort(asc("name"), desc("age"))
         .build();

DocumentCollectionManager manager = // instance;
DocumentDeleteQuery query = DocumentQueryBuilder.delete().from("collection")
                                                .where("age").gt(10).build();
manager.delete(query);
//using builder
DocumentDeleteQuery query = DocumentQueryBuilder.builder().from("collection")
                                                .where(DocumentCondition.gt("age", 10).build();

ColumnEntity entity = ColumnEntity.of("columnFamily");

Column diana = Column.of("name", "Diana");

entity.add(diana);

List<ColumnEntity> entities = Collections.singletonList(entity);
ColumnFamilyManager manager = // instance;

// Insert operations
manager.insert(entity);

manager.insert(entity, Duration.ofHours(2L)); // inserts with two hours of TTL

manager.insert(entities, Duration.ofHours(2L)); // inserts with two hours of TTL

// Update operations
manager.update(entity);

manager.update(entities);

ColumnQuery query = ColumnQuery.select().from("Person").build();
//static imports
ColumnQuery query = select().from("Person").build();

ColumnQuery query = ColumnQuery.builder().from("Person").build();
//static imports
ColumnQuery query = builder().from("Person").build();

 ColumnQuery query = ColumnQuery.select()
                .from("Person").where("name").eq("Ada Lovelace")
                .build();
//static imports
 ColumnQuery query = select()
                .from("Person").where("name").eq("Ada Lovelace")
                .build();

ColumnQuery query = ColumnQuery.builder()
                .from("Person").where(ColumnCondition.eq("name", "Ada Lovelace"))
                .build();
//static imports
ColumnQuery query = builder().from("Person")
                               .where(eq("name", "Ada Lovelace"))
                               .build();

  ColumnQuery query = ColumnQuery.select("name")
                .from("Person").where("name").eq("Ada Lovelace")
                .build();
//static imports
  ColumnQuery query = select("name")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .build();

  ColumnQuery query = ColumnQuery.builder("name")
                .from("Person").where(ColumnCondition.eq("name", "Ada Lovelace"))
                .build();
//static imports

  ColumnQuery query = builder("name")
                .from("Person").where(eq("name", "Ada Lovelace"))
                .build();

ColumnQuery query = ColumnQuery.select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .and("age").gt(20)
                .build();
//static imports
ColumnQuery query = select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .and("age").gt(20)
                .build();

ColumnQuery query = ColumnQuery.builder("name", "age")
             .from("Person")
             .where(ColumnCondition.and(ColumnCondition.eq("name", "Ada Lovelace"),
             DocumentCondition.gt("age", 20)))
             .build();

//static imports

ColumnQuery query = builder("name", "age")
             .from("Person")
             .where(and(eq("name", "Ada Lovelace"),
             gt("age", 20)))
             .build();

  ColumnQuery query = ColumnQuery.select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .or("age").gt(20)
                .build();
//static imports
  ColumnQuery query = select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .or("age").gt(20)
                .build();

ColumnQuery query = ColumnQuery.builder("name", "age")
             .from("Person")
             .where(ColumnCondition.or(ColumnCondition.eq("name", "Ada Lovelace"),
             ColumnCondition.gt("age", 20)))
             .build();

//static imports

ColumnQuery query = builder("name", "age")
             .from("Person")
             .where(or(eq("name", "Ada Lovelace"),
             gt("age", 20)))
             .build();

ColumnQuery query = ColumnQuery.select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .or("age").gt(20)
                .skip(1)
                .limit(2)
                .build();
//static imports
ColumnQuery query = select("name", "age")
                .from("Person")
                .where("name").eq("Ada Lovelace")
                .or("age").gt(20)
                .skip(1)
                .limit(2)
                .build();

ColumnQuery query = ColumnQuery.builder("name", "age")
                .from("Person")
                .where(ColumnCondition.or(ColumnCondition.eq("name", "Ada Lovelace"),
                        ColumnCondition.gt("age", 20)))
                .skip(1).limit(2)
                .build();

//static imports

ColumnQuery query = builder("name", "age")
                .from("Person")
                .where(or(eq("name", "Ada Lovelace"),
                        gt("age", 20)))
                .skip(1).limit(2)
                .build();

ColumnQuery query = ColumnQuery.select("name", "age")
            .from("Person")
            .where("name").eq("Ada Lovelace")
            .or("age").gt(20)
            .orderBy("name").asc()
            .orderBy("desc").desc()
            .build();

 ColumnQuery query = ColumnQuery.builder("name", "age")
         .from("Person")
         .where(DocumentCondition.or(DocumentCondition.eq("name", "Ada Lovelace"),
                DocumentCondition.gt("age", 20)))
         .sort(Sort.asc("name"), Sort.desc("age"))
         .build();

//static imports

ColumnQuery query = builder("name", "age")
         .from("Person")
         .where(or(eq("name", "Ada Lovelace"),
                gt("age", 20)))
         .sort(asc("name"), desc("age"))
         .build();

ColumnFamilyManager manager = // instance;
ColumnDeleteQuery query = ColumnDeleteQuery.delete().from("collection")
                                                .where("age").gt(10).build();
manager.delete(query);
//using builder
ColumnDeleteQuery query = ColumnDeleteQuery.builder().from("collection")
                                                .where(DocumentCondition.gt("age", 10).build();

Optional<Value> value = bucketManager.get("key");

Iterable<Value> values = bucketManager.get(Collections.singletonList("key"));

bucketManager.remove("key");

bucketManager.remove(Collections.singletonList("key"));

WHERE_CLAUSE ::= CONDITION ([and | or] CONDITION)*

ORDERING_CLAUSE ::= NAME [asc | desc] ( NAME [asc | desc])*

PreparedStatement preparedStatement = documentManager
        .prepare("select * from Person where name = @name");

preparedStatement.bind("name", "Ada");

Stream<DocumentEntity> adas = preparedStatement.getResult();

PreparedStatementAsync preparedStatement = documentManagerAsync
        .prepare("select * from Person where name = @name");

preparedStatement.bind("name", "Ada");

Consumer<Stream<DocumentEntity>> callback = //instance;

preparedStatement.getResult(callback);

@Entity
public class Person {
}

@Entity("ThePerson")
public class Person {
}

@Entity
public class Person {

    @Id
    private Long id;

    @Column
    private String name;

    @Column
    private Address address;
}


@Entity
public class Address {

    @Column
    private String street;

    @Column
    private String city;
}

{
   "_id":10,
   "name":"Ada Lovelave",
   "address":{
      "city":"São Paulo",
      "street":"Av Nove de Julho"
   }
}

@Entity
public class Person {
    @Column
    private String nickname;

    @Column("personName")
    private String name;

    @Column
    private List<String> phones;

    // ignored
    private String address;
}

@Entity
public class Dog extends Animal {

    @Column
    private String name;
}

@MappedSuperclass
public class Animal {

    @Column
    private String race;

    @Column
    private Integer age;
}

@Entity
public class User implements Serializable {

    @Id
    private String userName;

    @Column
    private String name;

    @Column
    private List<String> phones;
}

@Entity
public class Book {

    @Column
    private String title;

    @Column
    private Author author;
}

@Embeddable
public class Author {

    @Column
    private String author;

    @Column
    private Integer age;
}

@Entity
public class Employee {

    @Column
    private String name;

    @Column
    private Job job;

    @Column("money")
    @Convert(MoneyConverter.class)
    private MonetaryAmount salary;
}

public class MoneyConverter implements AttributeConverter<MonetaryAmount, String> {

    @Override
    public String convertToDatabaseColumn(MonetaryAmount appValue) {
        return appValue.toString();
    }

    @Override
    public MonetaryAmount convertToEntityAttribute(String dbValue) {
        return MonetaryAmount.parse(dbValue);
    }
}

public class MonetaryAmount {
    private final String currency;

    private final BigDecimal value;

    public String toString() {
        // specific implementation
    }

    public static MonetaryAmount parse(String string) {
        // specific implementation
    }
}

@Entity
public class Person {

    @Id
    private Long id;

    @Column
    private String name;

    @Column
    private List<String> phones;

    @Column
    private List<Address> addresses;
}

@Embeddable
public class Address {

    @Column
    private String street;

    @Column
    private String city;
}

{
   "_id":10,
   "addresses":[
      {
         "city":"São Paulo",
         "street":"Av Nove de Julho"
      },
      {
         "city":"Salvador",
         "street":"Rua Engenheiro Jose Anasoh"
      }
   ],
   "name":"Name",
   "phones":[
      "234",
      "432"
   ]
}

Person poliana = // instance;
Book shack = // instance;
EdgeEntity edge = graphTemplate.edge(poliana, "reads", shack);
reads.add("where", "Brazil");
Person out = edge.getOutgoing();
Book in = edge.getIncoming();

List<Person> developers = graph.getTraversalVertex()
       .has("salary", gte(3_000D))
       .has("age", between(20, 25))
       .has("occupation", "Developer")
       .<Person>stream().collect(toList());

List<Person> developers = graph.getTraversalVertex()
        .has("salary", gte(3_000D))
        .has("age", between(20, 25))
        .has("occupation", "Developer")
        .<Person>stream().out("knows").collect(toList());

@Inject
private GraphTemplate template;

@Produces
public Graph getManager() {
    Graph graph = // instance;
    return graph;
}

@Inject
@Database(value = DatabaseType.GRAPH, provider = "databaseA")
private GraphTemplate templateA;

@Inject
@Database(value = DatabaseType.GRAPH, provider = "databaseB")
private GraphTemplate templateB;

// producers methods
@Produces
@Database(value = DatabaseType.GRAPH, provider = "databaseA")
public Graph getManagerA() {
    Graph manager = // instance;
    return graph;
}

@Produces
@Database(value = DatabaseType.GRAPH, provider = "databaseB")
public Graph getManagerB() {
    Graph graph = // instance;
    return graph;
}

@Inject
private GraphTemplateProducer producer;

public void sample() {
   Graph graphA = // instance;
   Graph graphB = // instance;
   GraphTemplate templateA = producer.get(graphA);
   GraphTemplate templateB = producer.get(graphB);
}

KeyValueTemplate template = // instance;
Stream<User> users = template.query("get \"Diana\"");
template.query("remove \"Diana\"");

ColumnTemplate template = // instance;
Stream<Person> result = template.query("select * from Person where id = 1");

DocumentTemplate template = // instance;
Stream<Person> result = template.query("select * from Person where age > 10");

GraphTemplate template = // instance;
Stream<City> cities = template.query("g.V().hasLabel('City')");

PreparedStatement preparedStatement = documentTemplate
        .prepare("select * from Person where name = @name");

preparedStatement.bind("name", "Ada");

Stream<Person> adas = preparedStatement.getResult();

// Keep using gremlin for Graph databases
PreparedStatement prepare = graphTemplate().prepare("g.V().hasLabel(param)");

prepare.bind("param", "Person");

Stream<Person> people = preparedStatement.getResult();

   interface PersonRepository extends Repository<Person, Long> {

        List<Person> findAll(Pagination pagination);

        List<Person> findByName(String name, Sort sort);

        List<Person> findByAgeGreaterThan(Integer age, Sorts sorts);
    }

PersonRepository personRepository = //instance;

Sort sort = Sort.asc("name");

Sorts sorts = Sorts.sorts().asc("name").desc("age");

Pagination pagination = Pagination.page(1).size(10);

List<Person> all = personRepository.findAll(pagination);//findAll by pagination

List<Person> byName = personRepository.findByName("Ada", sort);//find by name order by name asc

List<Person> byAgeGreaterThan = personRepository.findByAgeGreaterThan(22, sorts);//find age greater than 22 sort name asc then age desc

ColumnTemplate template = //instance;
Pagination pagination = Pagination.page(1).size(1);
ColumnQuery query = ColumnQueryPagination.of(select().from("person").build(), pagination);
Stream<Person> people = template.select(query);

ColumnTemplate template = //instance;
Pagination pagination = Pagination.page(1).size(1);
ColumnQueryPagination query = ColumnQueryPagination.of(
        select().from("person").build(), pagination);
Page<Person> firstPage = template.select(query);
Stream<Person> firstPageContents = page.getContent();
Page<Person> secondPage = firstPage.next();

ColumnQueryMapperBuilder mapperBuilder = //instance;

Pagination pagination = Pagination.page(2).size(2);
ColumnQuery query = mapperBuilder.selectFrom(Person.class).build(pagination);
Page<Person> page = mapperBuilder.selectFrom(Person.class).page(template, pagination);
Stream<Person> people = mapperBuilder.selectFrom(Person.class).getResult(template, pagination);

 interface PersonRepository extends Repository<Person, Long> {

    List<Person> findAll(Pagination pagination);

    Set<Person> findByName(String name, Pagination pagination);

    Page<Person> findByAge(Integer age, Pagination pagination);
}

DocumentTemplate template = //instance;
Pagination pagination = Pagination.page(1).size(1);
DocumentQuery query = DocumentQueryPagination.of(
        select().from("person").build(), pagination);
Stream<Person> people = template.select(query);

DocumentTemplate template = //instance;
Pagination pagination = Pagination.page(1).size(1);
DocumentQueryPagination query = DocumentQueryPagination.of(
        select().from("person").build(), pagination);
Page<Person> firstPage = template.select(query);
Stream<Person> firstPageContents = page.getContent();
Page<Person> secondPage = firstPage.next();

DocumentQueryMapperBuilder mapperBuilder = //instance;

Pagination pagination = Pagination.page(2).size(2);
DocumentQuery query = mapperBuilder.selectFrom(Person.class).build(pagination);
Page<Person> page = mapperBuilder.selectFrom(Person.class).page(template, pagination);
Stream<Person> people = mapperBuilder.selectFrom(Person.class)
        .getResult(template, pagination);

 interface PersonRepository extends Repository<Person, Long> {

    List<Person> findAll(Pagination pagination);

    Set<Person> findByName(String name, Pagination pagination);

    Page<Person> findByAge(Integer age, Pagination pagination);
}

 interface PersonRepository extends Repository<Person, Long> {

    List<Person> findAll(Pagination pagination);

    Set<Person> findByName(String name, Pagination pagination);
}