// build.gradle.kts

plugins {
    kotlin("kapt") version "1.9.21"
}

dependencies {
    implementation("com.Querydsl:Querydsl-jpa:5.1.0:jakarta")
    kapt("com.Querydsl:Querydsl-apt:5.1.0:jakarta")
}

interface AdminRepository : JpaRepository<Admin, UUID> {
    fun findByEmail(email: String): Optional<Admin>
}

interface AdminRepository : JpaRepository<Admin, UUID> {
    @Query(value = "SELECT a FROM Admin a JOIN AdminMeta b on a.id = b.adminId WHERE b.isActive is true ")
    fun findActive(): List<Admin>
}

fun findPrivateStores(): List<Store> {
    val cb = entityManager.criteriaBuilder
    return cb
        .createQuery(Store::class.java)
        .apply {
            val store = from(Store::class.java)

            select(store)
                .where(cb.equal(store.get<StoreType>("storeType"), StoreType.private))
        }
        .let { entityManager.createQuery(it).resultList }
}

interface StoreRepository : JpaRepository<Store, UUID>, JpaSpecificationExecutor<Store>

data class StoreSpecification(
    val createdAtGte: OffsetDateTime?,
    val createdAtLte: OffsetDateTime?,
) : Specification<Store> {
    override fun toPredicate(root: Root<Store>, query: CriteriaQuery<*>, builder: CriteriaBuilder): Predicate {
        val predicates = mutableListOf<Predicate>()

        createdAtGte?.let {
            predicates.add(builder.greaterThanOrEqualTo(root.get("createdAt"), it))
        }

        createdAtLte?.let {
            predicates.add(builder.lessThanOrEqualTo(root.get("createdAt"), it))
        }

        return builder.and(*predicates.toTypedArray())
    }

}

test("test specification") {
    storeRepository.findAll(
        StoreSpecification(
            createdAtGte = null,
            createdAtLte = null,
        )
    )
    // select * from store s1_0 where 1=1;

    storeRepository.findAll(
        StoreSpecification(
            createdAtGte = OffsetDateTime.now(),
            createdAtLte = null,
        )
    )
    // select * from store s1_0 where s1_0.created_at>='2021-01-01T01:00:00.000+0900';

    storeRepository.findAll(
        StoreSpecification(
            createdAtGte = null,
            createdAtLte = OffsetDateTime.now(),
        )
    )
    // select * from store s1_0 where s1_0.created_at<='2024-04-26T23:04:53.156+0900';

    storeRepository.findAll(
        StoreSpecification(
            createdAtGte = OffsetDateTime.now(),
            createdAtLte = OffsetDateTime.now(),
        )
    )
    // select * from store s1_0 where s1_0.created_at>='2024-04-26T23:04:53.162+0900' and s1_0.created_at<='2024-04-26T23:04:53.162+0900';
}

interface StoreRepository : JpaRepository<Store, UUID>, KotlinJdslJpqlExecutor

val namePredicate = "JDSL 매장"

storeRepository.findAll {
    select(entity(Store::class))
        .from(entity(Store::class))
        .where(
            path(Store::name).like("%$namePredicate%")
        )
}

implementation("com.linecorp.kotlin-jdsl:jpql-dsl:$jdslVersion")
implementation("com.linecorp.kotlin-jdsl:jpql-render:$jdslVersion")
implementation("com.linecorp.kotlin-jdsl:spring-data-jpa-support:$jdslVersion")

@DataJpaTest
@Import(
    KotlinJdslAutoConfiguration::class,
)
abstract class RepositoryTestBase

interface AdminRepository : JpaRepository<Admin, UUID>, KotlinJdslJpqlExecutor

class AdminService(
    private val bookRepository: BookRepository,
) {
    fun getByFilter(
        filter: SearchFilter<Admin>,
    ): List<Admin> {
        return bookRepository.findAll {
            select(entity(Admin::class))
                .from(entity(Admin::class))
                .whereAnd(
                    path(Admin::email).like("%${filter.email}%"),
                )
        }
        .filterNotNull()
    }
}

interface AdminRepository : JpaRepository<Admin, UUID>, CustomAdminRepository {
    fun findByEmail(email: String): Optional<Admin>
}

interface CustomAdminRepository {
    fun findByFilter(
        filter: SearchFilter<Admin>
    ): List<Admin>
}

class CustomAdminRepositoryImpl(
    private val kotlinJdslJpqlExecutor: KotlinJdslJpqlExecutor,
) : CustomAdminRepository {
    override fun findByFilter(
        filter: SearchFilter<Admin>
    ): List<Admin> {
        return kotlinJdslJpqlExecutor
            .findAll {
                select(entity(Admin::class))
                    .from(entity(Admin::class))
                    .whereAnd(
                        path(Admin::email).like("%${filter.email}%"),
                    )
            }
            .filterNotNull()
    }
}

class AdminService(
    private val adminRepository: AdminRepository,
) {
    fun getByFilter(
        filter: SearchFilter<Admin>,
    ): List<Admin> {
        return adminRepository.findByFilter(filter)
    }
}

override fun findAllActive(
    orderableVendorId: UUID,
    storeIds: List<UUID>,
): List<Bill> {
    return jpaQueryFactory
        .selectFrom(bill)
        .where(
            bill.orderableVendor.id.eq(orderableVendorId)
                .and(bill.store.id.`in`(storeIds))
                .and(bill.state.eq(BillState.ACTIVE)),
        )
        .setLockMode(LockModeType.PESSIMISTIC_WRITE)
        .setHint("org.hibernate.cacheable", false)
        .setHint("jakarta.persistence.lock.timeout", 10000)
        .fetch()
}

class CustomBillRepositoryImpl(
    private val kotlinJdslJpqlExecutor: KotlinJdslJpqlExecutor,
    private val entityManager: EntityManager,
    private val jpqlRenderContext: RenderContext,
) : CustomBillRepository {
    override fun findAllActive(
        orderableVendorId: UUID,
        storeIds: List<UUID>,
    ): List<Bill> {
        val query = jpql {
            select(entity(Bill::class))
                .from(entity(Bill:class))
                .whereAnd(
                    path(Bill::orderableVendor)(OrderableVendor::getId).eq(orderableVendorId),
                    path(Bill::store)(Store::getId).customIn(storeIds),
                    path(Bill::state).eq(BillState.ACTIVE),
                )
        }
        
        return entityManager
            .createQuery(query, jpqlRenderContext)
            .apply { 
                lockMode = LockModeType.PESSIMISTIC_WRITE
                setHint(HINT_CACHEABLE, false)
                setHint(HINT_SPEC_LOCK_TIMEOUT, 10000)
            }
            .resultList
    }
}

@Entity
class Actor(
    @Column(nullable = false)
    val name: String,
) {
    @Id
    val id: UUID = UUID.randomUUID()
}

@Entity
class Board(
    @Column(nullable = false)
    val title: String,

    @Column(nullable = false)
    val content: String,

    @ManyToOne(fetch = FetchType.LAZY)
    val actor: Actor,
) {
    @Id
    val id: UUID = UUID.randomUUID()
}

interface BoardRepository : JpaRepository<Board, UUID>, CustomBoardRepository

interface CustomBoardRepository {
    fun findByActorName(actorName: String, pageable: Pageable): Page<Board?>
}

class CustomBoardRepositoryImpl(
    private val kotlinJdslJpqlExecutor: KotlinJdslJpqlExecutor,
) : CustomBoardRepository {
    override fun findByActorName(actorName: String, pageable: Pageable): Page<Board?> {
        return kotlinJdslJpqlExecutor.findPage(pageable) {
            select(entity(Board::class))
                .from(
                    entity(Board::class),
                    fetchJoin(Board::actor),
                )
                .where(path(Board::actor)(Actor::name).eq(actorName))
        }
    }
}

@Entity
class Board(
    @Column(nullable = false)
    val title: String,

    @Column(nullable = false)
    val content: String,
) {
    @Id
    val id: UUID = UUID.randomUUID()
}

@Entity
class BoardStats(
    @Column(nullable = false)
    val boardId: UUID,

    @Column
    val viewCount: Int,
) {
    @Id
    val id: UUID = UUID.randomUUID()
}

interface BoardRepository : JpaRepository<Board, UUID>, KotlinJdslJpqlExecutor

@Test
fun test_findPage() {
    val pageable = PageRequest.of(5, 10)

    val actual = boardRepository.findPage(pageable) {
        selectDistinctNew<Pair<Board, Int?>>(
            entity(Board::class),
            path(BoardStats::viewCount),
        )
            .from(
                entity(Board::class),
                leftJoin(BoardStats::class)
                    .on(path(Board::id).eq(path(BoardStats::boardId)),)
            )
    }
    
    assertEquals(5, actual.totalElements)
}

override fun findRecentOrderSheetsByStoreId(
    storeId: UUID,
    count: Int,
): List<OrderSheet> {
    return from(orderSheet)
        .where(
            orderSheet.storeId.eq(storeId),
        )
        .orderBy(orderSheet.updatedAt.desc())
        .limit(count.toLong())
        .fetch()
}

data class JpqlLimit<T : Any>(
    val selectQuery: QueryPart,
    val limit: Long,
    override val returnType: KClass<T>,
) : SelectQuery<T>

object JpqlLimitSerializer : JpqlSerializer<JpqlLimit<*>> {
    override fun handledType(): KClass<JpqlLimit<*>> {
        return JpqlLimit::class
    }

    override fun serialize(
        part: JpqlLimit<*>,
        writer: JpqlWriter,
        context: RenderContext,
    ) {
        val delegate = context.getValue(JpqlRenderSerializer)

        delegate.serialize(part.selectQuery, writer, context)

        writer.write(" LIMIT ${part.limit}")
    }
}

class CustomJpql : Jpql() {
    companion object Constructor : JpqlDsl.Constructor<CustomJpql> {
        override fun newInstance(): CustomJpql = CustomJpql()
    }

    inline fun <reified T : Any> JpqlQueryable<SelectQuery<T>>.limit(limit: Int): JpqlLimit<T> {
        return JpqlLimit(
            this.toQuery(),
            limit.toLong(),
            T::class,
        )
    }
}

override fun findRecentOrderSheetsByStoreId(
    storeId: UUID,
    count: Int,
): List<OrderSheet> {
    return kotlinJdslJpqlExecutor
        .findAll {
            select(entity(OrderSheet::class))
                .from(entity(OrderSheet::class))
                .where(path(OrderSheet::storeId).eq(storeId))
                .orderBy(path(OrderSheet::updatedAt).desc())
                .limit(count)
        }
        .filterNotNull()
}

override fun findRecentOrderSheetsByStoreId(
    storeId: UUID,
    count: Int,
): List<OrderSheet> {
    return kotlinJdslJpqlExecutor
        .findAll {
            select(entity(OrderSheet::class))
                .from(entity(OrderSheet::class))
                .where(path(OrderSheet::storeId).eq(storeId))
                .limit(count)
        }
        .filterNotNull()
}

override fun findRecentOrderSheetsByStoreId(
    storeId: UUID,
    count: Int,
): List<OrderSheet> {
    val query = jpql {
        select(entity(OrderSheet::class))
              .from(entity(OrderSheet::class))
              .where(path(OrderSheet::storeId).eq(storeId))
    }
    
    return entityManager
            .createQuery(query, jpqlRenderContext)
            .apply { setMaxResults(count) }
            .resultList
}

class CustomOrderSheetRepositoryImpl(
    private val jdslExecutorSupport: JdslExecutorSupport,
) : CustomOrderSheetRepository

class CustomBillRepositoryImpl(
    private val kotlinJdslJpqlExecutor: KotlinJdslJpqlExecutor,
    private val entityManager: EntityManager,
    private val jpqlRenderContext: RenderContext,
) : CustomBillRepository {
    override fun findByIdUsingPessimisticLock(id: UUID): Optional<OrderSheet> {
        val query = jpql {
            select(entity(OrderSheet::class))
                .from(eneity(OrderSheet::class))
                .where(path(OrderSheet::getId).eq(id))
        }
            
        return entityManager
            .createQuery(query, jpqlRenderContext)
            .apply {
                lockMode = LockModeType.PESSIMISTIC_WRITE
                setHint(HINT_CACHEABLE, false)
                setHint(HINT_SPEC_LOCK_TIMEOUT, 10000)
            }
            .resultList
            .firstOrNull()
            .let { Optional.ofNullable(it) }
    }
}

@Component
class JdslExecutorSupport(
    private val kotlinJdslJpqlExecutor: KotlinJdslJpqlExecutor,
    private val entityManager: EntityManager,
    private val jpqlRenderContext: RenderContext,
) {
    fun <T : Any> findWithPessimisticLock(init: JpqlDsl.() -> JpqlQueryable<SelectQuery<T>>): Optional<T> {
        return entityManager
            .createQuery(jpql(CustomJpql, init), jpqlRenderContext)
            .apply {
                lockMode = LockModeType.PESSIMISTIC_WRITE
                setHint(HINT_CACHEABLE, false)
                setHint(HINT_SPEC_LOCK_TIMEOUT, 10000)
            }
            .resultList
            .firstOrNull()
            .let { Optional.ofNullable(it) }
    }
}

class CustomOrderSheetRepositoryImpl(
    private val jdslExecutorSupport: JdslExecutorSupport,
) : CustomOrderSheetRepository {
    override fun findByIdUsingPessimisticLock(id: UUID): Optional<OrderSheet> {
        return jdslExecutorSupport
            .findWithPessimisticLock {
                selectFrom(OrderSheet::class)
                    .where(path(OrderSheet::getId).eq(id))
            }
    }
}

override fun findByFilter(
    filter: SearchFilter<Admin>
): List<Admin> {
    return kotlinJdslJpqlExecutor
        .findAll {
            select(entity(Admin::class))
                .from(entity(Admin::class))
                .whereAnd(
                    path(Admin::email).like("%${filter.email}%"),
                )
        }
        .filterNotNull()
}

@Component
class JdslExecutorSupport(
    private val kotlinJdslJpqlExecutor: KotlinJdslJpqlExecutor,
    private val entityManager: EntityManager,
    private val jpqlRenderContext: RenderContext,
) {
    fun <T : Any> findAll(init: JpqlDsl.() -> JpqlQueryable<SelectQuery<T>>): List<T> {
        return kotlinJdslJpqlExecutor
            .findAll(CustomJpql, init)
            .filterNotNull()
    }
}

override fun findByFilter(
    filter: SearchFilter<Admin>
): List<Admin> {
    return jdslExecutorSupport
        .findAll {
            select(entity(Admin::class))
                .from(entity(Admin::class))
                .whereAnd(
                    path(Admin::email).like("%${filter.email}%"),
                )
        }
}

override fun findActive(
    orderableVendorId: UUID,
    storeId: UUID,
): Optional<Bill> {
    return kotlinJdslJpqlExecutor
        .findAll {
            select(entity(Bill::class))
                .from(entity(Bill::class))
                .whereAnd(
                    path(Bill::orderableVendor)(OrderableVendor::getId).eq(orderableVendorId),
                    path(Bill::store)(Store::getId).eq(storeId),
                    path(Bill::state).eq(BillState.ACTIVE),
                )
        }
        .firstOrNull()
        .let { Optional.ofNullable(it) }
}

@Component
class JdslExecutorSupport(
    private val kotlinJdslJpqlExecutor: KotlinJdslJpqlExecutor,
    private val entityManager: EntityManager,
    private val jpqlRenderContext: RenderContext,
) {
    fun <T : Any> find(init: Jpql.() -> JpqlQueryable<SelectQuery<T>>): Optional<T> {
        return getOrNull(init).let { Optional.ofNullable(it) }
    }

    fun <T : Any> getOrNull(init: Jpql.() -> JpqlQueryable<SelectQuery<T>>): T? {
        return kotlinJdslJpqlExecutor
            .findAll(init)
            .firstOrNull()
    }
}

override fun findActive(
    orderableVendorId: UUID,
    storeId: UUID,
): Optional<Bill> {
    return jdslExecutorSupport
        .find {
            selectFrom(Bill::class)
                .whereAnd(
                    path(Bill::orderableVendor)(OrderableVendor::getId).eq(orderableVendorId),
                    path(Bill::store)(Store::getId).eq(storeId),
                    path(Bill::state).eq(BillState.ACTIVE),
                )
        }
}

fun <T : Any> getOrNull(init: Jpql.() -> JpqlQueryable<SelectQuery<T>>): T? {
    return entityManager
            .createQuery(init, jpqlRenderContext)
            .apply { setMaxResults(1) }
            .resultList
            .firstOrNull()
}

class CustomJpql : Jpql() {
    private val falsePredicate get() = booleanLiteral(false).eq(booleanLiteral(true))
    val truePredicate get() = booleanLiteral(true).eq(booleanLiteral(true))

    companion object Constructor : JpqlDsl.Constructor<CustomJpql> {
        override fun newInstance(): CustomJpql = CustomJpql()
    }

    fun <T : Enum<*>> Expressionable<Array<T>>.arrayContains(value: T): Predicate {
        return JpqlArrayContain(this.toExpression(), value)
    }

    fun <T> Expressionable<List<T>>.jsonbExistsAny(value: List<T>): Predicate {
        return JpqlJsonbExistsAny(this.toExpression(), value(value.map { it.toString() }.toTypedArray()))
    }

    fun <T : Any, S : T?> Expressionable<T>.`in`(compareValues: Collection<S>): Predicate {
        if (compareValues.isEmpty()) {
            return falsePredicate
        }

        return Predicates.`in`(this.toExpression(), compareValues.map { Expressions.value(it) })
    }

    inline fun <reified T : Any> selectFrom(type: KClass<T>): SelectQueryWhereStep<T> {
        val entity = entity(type)
        return select(entity).from(entity)
    }
}

data class JpqlArrayContain<T : Enum<*>>(
    val value: Expression<Array<T>>,
    val compareValues: T,
) : Predicate

object JpqlArrayContainsSerializer : JpqlSerializer<JpqlArrayContain<*>> {
    override fun handledType(): KClass<JpqlArrayContain<*>> {
        return JpqlArrayContain::class
    }

    override fun serialize(
        part: JpqlArrayContain<*>,
        writer: JpqlWriter,
        context: RenderContext,
    ) {
        val delegate = context.getValue(JpqlRenderSerializer)

        // ARRAY_POSITION({0}, {1}) is not null
        writer.write("ARRAY_POSITION(")
        delegate.serialize(part.value, writer, context)
        writer.write(", ")
        writer.write("'${part.compareValues.name}'")
        writer.write(") IS NOT NULL")
    }
}

data class JpqlJsonbExistsAny<T>(
    val value: Expression<List<T>>,
    val compareValues: Expression<Array<*>>,
) : Predicate

object JpqlJsonbExistsAnySerializer : JpqlSerializer<JpqlJsonbExistsAny<*>> {
    override fun handledType(): KClass<JpqlJsonbExistsAny<*>> {
        return JpqlJsonbExistsAny::class
    }

    override fun serialize(
        part: JpqlJsonbExistsAny<*>,
        writer: JpqlWriter,
        context: RenderContext,
    ) {
        val delegate = context.getValue(JpqlRenderSerializer)

        // FUNCTION('jsonb_exists_any', {0}, {1}) = true
        writer.write("FUNCTION('jsonb_exists_any', ")
        delegate.serialize(part.value, writer, context)
        writer.write(", ")
        delegate.serialize(part.compareValues, writer, context)
        writer.write(") = true")
    }
}

fun <T : Enum<*>> Expressionable<Array<T>>.arrayContains(value: T): Predicate {
    return JpqlArrayContain(this.toExpression(), value)
}

fun <T> Expressionable<List<T>>.jsonbExistsAny(value: List<T>): Predicate {
    return JpqlJsonbExistsAny(this.toExpression(), value(value.map { it.toString() }.toTypedArray()))
}

override fun findRecommendations(
    category: MajorTradeStoreCategory,
    towns: List<Town>,
): List<OrderableVendor> {
    return jdslExecutorSupport
        .findAll {
            selectFrom(OrderableVendor::class)
                .whereAnd(
                    path(OrderableVendor::metaInfo)
                        .path(MetaOrderableVendor::advertisementEnabled)
                        .eq(true),
                    path(OrderableVendor::metaInfo)
                        .path(MetaOrderableVendor::productInfo)
                        .path(OrderableVendorProductInfo::majorTradeStoreCategories)
                        .arrayContains(category),
                    path(OrderableVendor::metaInfo)
                        .path(MetaOrderableVendor::deliveryInfo)
                        .path(OrderableVendorDeliveryInfo::deliveryTowns)
                        .jsonbExistsAny(towns),
                )
        }
}

class CustomJpql : Jpql() {
    private val falsePredicate get() = booleanLiteral(false).eq(booleanLiteral(true))

    fun <T : Any, S : T?> Expressionable<T>.`in`(compareValues: Collection<S>): Predicate {
        if (compareValues.isEmpty()) {
            return falsePredicate
        }

        return Predicates.`in`(this.toExpression(), compareValues.map { Expressions.value(it) })
    }
}

override fun findAllActive(
    orderableVendorId: UUID,
    storeIds: List<UUID>,
): List<Bill> {
    return jdslExecutorSupport
        .findAllWithPessimisticLock {
            selectFrom(Bill::class)
                .whereAnd(
                    path(Bill::orderableVendor)(OrderableVendor::getId).eq(orderableVendorId),
                    path(Bill::store)(Store::getId).`in`(storeIds),
                    path(Bill::state).eq(BillState.ACTIVE),
                )
        }
}

test("빈 매장 ID 목록이 주어지면 빈 목록을 반환한다.") {
    // Given
    // ...생략

    // When
    val actual = billRepository.findAllActive(
        orderableVendorId = orderableVendor.id,
        storeIds = listOf(),
    )

    // Then
    actual.shouldBeEmpty()
}

override fun findAllActive(
    storeId: UUID,
    pageRequest: Pageable,
): Page<Bill> {
    return jdslExecutorSupport
        .findPage(pageRequest) {
            select(entity(Bill::class))
                .from(entity(Bill::class))
                .whereAnd(
                    path(Bill::store)(Store::getId).eq(storeId),
                    path(Bill::state).eq(BillState.ACTIVE),
                )
                .orderBy(path(Bill::orderableVendor)(OrderableVendor::name).asc())
        }
}

inline fun <reified T : Any> selectFrom(type: KClass<T>): SelectQueryWhereStep<T> {
    val entity = entity(type)
    return select(entity).from(entity)
}

override fun findAllActive(
    storeId: UUID,
    pageRequest: Pageable,
): Page<Bill> {
    return jdslExecutorSupport
        .findPage(pageRequest) {
            selectFrom(Bill::class)
                .whereAnd(
                    path(Bill::store)(Store::getId).eq(storeId),
                    path(Bill::state).eq(BillState.ACTIVE),
                )
                .orderBy(path(Bill::orderableVendor)(OrderableVendor::name).asc())
        }
}

@Entity
class Product {
    // ...생략
    
    @ManyToMany(fetch = FetchType.LAZY, mappedBy = "mutableProducts")
    protected val mutableTags: MutableList<OrderableVendorProductTag> = mutableListOf()
    val tags: List<Tag> get() = mutableTags.toList()
}

@Entity
class Tag {
    // ...생략
    
    @ManyToMany(fetch = FetchType.LAZY, cascade = [CascadeType.PERSIST, CascadeType.MERGE])
    @JoinTable(
        name = "product_tag_assoc",
        joinColumns = [JoinColumn(name = "tag_id")],
        inverseJoinColumns = [JoinColumn(name = "product_id")],
    )
    protected var mutableProducts: MutableList<Product> = mutableListOf()
    val products: List<Product> get() = mutableProducts.toList()
}

@Entity
@IdClass(ProductTagAssocId::class)
class ProductTagAssoc(
    id: ProductTagAssocId,
) {
    @Id
    @Column(name = "product_id", nullable = false)
    val productId: UUID = id.productId

    @Id
    @Column(name = "tag_id", nullable = false)
    val tagId: UUID = id.tagId
}

data class ProductTagAssocId(
    val productId: UUID,
    val tagId: UUID,
) : Serializable


override fun findByTagId(
    tagId: UUID,
): List<Product> {
    return jdslExecutorSupport
        .findAll {
            selectFrom(Product::class)
                .where(
                    exists(
                        selectFrom(ProductTagAssoc::class)
                            .whereAnd(
                                path(ProductTagAssoc::tagId).eq(tagId),
                                path(ProductTagAssoc::productId).eq(path(Product::getId)),
                            )
                            .asSubquery()
                    )
                )
        }
}

override fun findByFilter(
    pageable: Pageable,
): Page<OrderableVendorCatalogProduct> {
    return jdslExecutorSupport
        .findPage(pageable) {
            selectFrom(Product::class)
                .orderBy(
                    caseWhen(path(Product::price).isNull())
                        .then(2)
                        .`else`(1)
                        .asc(),
                    path(Product::name).asc(),
                )
        }
}

fun writeParam(value: Any?) {
    val name = "param${incrementer.getNext()}"

    writeParam(name, value)
}

override fun findByFilter(
    pageable: Pageable,
): Page<OrderableVendorCatalogProduct> {
    return jdslExecutorSupport
        .findPage(pageable) {
            selectFrom(Product::class)
                .orderBy(
                    caseWhen(path(Product::price).isNull())
                        .then(intLiteral(2))
                        .`else`(intLiteral(1))
                        .asc(),
                    path(Product::name).asc(),
                )
        }
}