package example.micronaut.domain;

import io.micronaut.core.annotation.Creator;
import io.micronaut.data.annotation.GeneratedValue;
import io.micronaut.data.annotation.Id;
import io.micronaut.data.annotation.MappedEntity;

@MappedEntity
public class Thing {

    @Id
    @GeneratedValue
    private Long id;

    private final String name;

    @Creator
    public Thing(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }
}

package example.micronaut.repository;

import example.micronaut.domain.Thing;
import io.micronaut.core.annotation.NonNull;
import io.micronaut.data.jdbc.annotation.JdbcRepository;
import io.micronaut.data.model.query.builder.sql.Dialect;
import io.micronaut.data.repository.CrudRepository;

import java.util.List;
import java.util.Optional;

@JdbcRepository(dialect = Dialect.ORACLE)
public interface ThingRepository extends CrudRepository<Thing, Long> {

    @Override
    @NonNull
    List<Thing> findAll();

    Optional<Thing> findByName(String name);
}

package example.micronaut;

import example.micronaut.domain.Thing;
import example.micronaut.repository.ThingRepository;
import io.micronaut.context.annotation.Requires;
import io.micronaut.context.event.StartupEvent;
import io.micronaut.runtime.event.annotation.EventListener;
import jakarta.inject.Singleton;

import javax.transaction.Transactional;
import java.util.Arrays;

@Singleton
@Requires(notEnv = "test")
public class DataPopulator {

    private final ThingRepository thingRepository;

    public DataPopulator(ThingRepository thingRepository) {
        this.thingRepository = thingRepository;
    }

    @EventListener
    @Transactional
    void init(StartupEvent event) {
        // clear out any existing data
        thingRepository.deleteAll();

        // create data
        Thing fred = new Thing("Fred");
        Thing barney = new Thing("Barney");
        thingRepository.saveAll(Arrays.asList(fred, barney));
    }
}

package example.micronaut.controller;

import example.micronaut.domain.Thing;
import example.micronaut.repository.ThingRepository;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.scheduling.TaskExecutors;
import io.micronaut.scheduling.annotation.ExecuteOn;

import javax.validation.constraints.NotBlank;
import java.util.List;
import java.util.Optional;

@Controller("/things")
@ExecuteOn(TaskExecutors.IO)
class ThingController {

    private final ThingRepository thingRepository;

    ThingController(ThingRepository thingRepository) {
        this.thingRepository = thingRepository;
    }

    @Get
    List<Thing> all() {
        return thingRepository.findAll();
    }

    @Get("/{name}")
    Optional<Thing> byName(@NotBlank String name) {
        return thingRepository.findByName(name);
    }
}

CREATE TABLE "THING" ("ID" NUMBER(19) PRIMARY KEY NOT NULL,"NAME" VARCHAR(255) NOT NULL);
CREATE SEQUENCE "THING_SEQ" MINVALUE 1 START WITH 1 NOCACHE NOCYCLE;

<logger name='io.micronaut.data.query' level='debug' />

micronaut:
  application:
    name: micronautguide
  executors:
    io:
      type: fixed
      nThreads: 75 (1)
flyway:
  datasources:
    default:
      enabled: true

datasources:
  default:
    ocid: (1)
    walletPassword: (2)
    username: micronautdemo
    password: (3)
oci:
  config:
    profile: DEFAULT (4)

package example.micronaut.repository;

import example.micronaut.domain.Thing;
import example.micronaut.repository.ThingRepository;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import org.junit.jupiter.api.Test;

import jakarta.inject.Inject;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;

@MicronautTest
class ThingRepositoryTest {

    @Inject
    ThingRepository thingRepository;

    @Test
    void testFindAll() {

        // clear out existing data; safe because each
        // test runs in a transaction that's rolled back
        thingRepository.deleteAll();
        assertEquals(0, thingRepository.count());

        thingRepository.saveAll(Arrays.asList(
                new Thing("t1"),
                new Thing("t2"),
                new Thing("t3")));

        List<Thing> things = thingRepository.findAll();
        assertEquals(3, things.size());
        assertEquals(
                Arrays.asList("t1", "t2", "t3"),
                things.stream()
                        .map(Thing::getName)
                        .sorted()
                        .collect(Collectors.toList()));
    }

    @Test
    void testFindByName() {
        String name = UUID.randomUUID().toString();

        Thing thing = thingRepository.findByName(name).orElse(null);
        assertNull(thing);

        thingRepository.save(new Thing(name));
        thing = thingRepository.findByName(name).orElse(null);
        assertNotNull(thing);
        assertEquals(name, thing.getName());
    }
}

<dependency>
    <groupId>io.micronaut.oraclecloud</groupId>
    <artifactId>micronaut-oraclecloud-vault</artifactId>
    <scope>compile</scope>
</dependency>

micronaut:
  application:
    name: micronautguide

micronaut:
  executors:
    io:
      type: fixed
      nThreads: 75
flyway:
  datasources:
    default:
      enabled: true

micronaut:
  config-client:
    enabled: true
oci:
  config:
    profile: DEFAULT (1)
  vault:
    config:
      enabled: true
    vaults:
      - ocid: (2)
        compartment-ocid: (3)

datasources:
  default:
    ocid: ocid1.autonomousdatabase.oc1.iad.anuwcl...
    walletPassword: ${ATP_WALLET_PASSWORD}
    username: micronautdemo
    password: ${ATP_USER_PASSWORD}