package example.micronaut.domain

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

@MappedEntity
class Thing @Creator constructor(val name: String) {
    @Id
    @GeneratedValue
    var id: Long? = null
}

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

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

    @NonNull
    override fun findAll(): List<Thing>

    fun findByName(name: String?): Optional<Thing>
}

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

@Singleton
@Requires(notEnv = ["test"])
open class DataPopulator(private val thingRepository: ThingRepository) {

    @EventListener
    @Transactional
    open fun init(event: StartupEvent) {
        // clear out any existing data
        thingRepository.deleteAll()

        // create data
        val fred = Thing("Fred")
        val barney = Thing("Barney")
        thingRepository.saveAll(listOf(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

@Controller("/things")
@ExecuteOn(TaskExecutors.IO)
class ThingController(private val thingRepository: ThingRepository) {

    @Get
    fun all(): List<Thing> = thingRepository.findAll()

    @Get("/{name}")
    fun byName(name: @NotBlank String?) = 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.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNotNull
import org.junit.jupiter.api.Assertions.assertNull
import org.junit.jupiter.api.Test
import java.util.UUID
import java.util.stream.Collectors

@MicronautTest
class ThingRepositoryTest(private val thingRepository: ThingRepository) {

    @Test
    fun 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(listOf(
                Thing("t1"),
                Thing("t2"),
                Thing("t3")))

        val things = thingRepository.findAll()
        assertEquals(3, things.size)
        assertEquals(
                listOf("t1", "t2", "t3"),
                things.stream()
                        .map(Thing::name)
                        .sorted()
                        .collect(Collectors.toList()))
    }

    @Test
    fun testFindByName() {
        val name = UUID.randomUUID().toString()

        var thing = thingRepository.findByName(name).orElse(null)
        assertNull(thing)

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

<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}