Thanks for your feedback, we will add this feature to the next release.

If you really need it currently, please do the following steps.

Create a class that represents match ... against ... expressions extending from ScalarExpression. An enum class MatchAgainstModifier that represents the modes is also needed.

data class MatchAgainstExpression(
    val matchColumns: List<ColumnExpression<*>>,
    val searchString: String,
    val modifier: MatchAgainstModifier? = null,
    override val sqlType: SqlType<Boolean> = BooleanSqlType,
    override val isLeafNode: Boolean = false
) : ScalarExpression<Boolean>()

enum class MatchAgainstModifier(private val value: String) {
    IN_NATURAL_LANGUAGE_MODE("in natural language mode"),
    IN_NATURAL_LANGUAGE_MODE_WITH_QUERY_EXPANSION("in natural language mode with query expansion"),
    IN_BOOLEAN_MODE("in boolean mode"),
    WITH_QUERY_EXPANSION("with query expansion");

    override fun toString(): String {
        return value
    }
}

Add DSL functions that can help us creating MatchAgainstExpression instances conveniently.

class MatchColumns(columns: List<ColumnExpression<*>>) : List<ColumnExpression<*>> by columns

fun match(vararg columns: Column<*>): MatchColumns {
    return MatchColumns(columns.map { it.asExpression() })
}

fun MatchColumns.against(searchString: String, modifier: MatchAgainstModifier? = null): MatchAgainstExpression {
    return MatchAgainstExpression(this, searchString, modifier)
}

Add a subclass of SqlFormatter, formatting MatchAgainstExpressions to SQL strings.

class CustomFormatter(database: Database, beautifySql: Boolean, indentSize: Int)
    : SqlFormatter(database, beautifySql, indentSize) {

    override fun visitUnknown(expr: SqlExpression): SqlExpression {
        if (expr is MatchAgainstExpression) {
            return visitMatchAgainst(expr)
        } else {
            return super.visitUnknown(expr)
        }
    }

    private fun visitMatchAgainst(expr: MatchAgainstExpression): MatchAgainstExpression {
        write("match (")
        visitExpressionList(expr.matchColumns)
        removeLastBlank()
        write(") against (?")
        _parameters += ArgumentExpression(expr.searchString, VarcharSqlType)
        expr.modifier?.let { write(" $it") }
        write(")")
        return expr
    }
}

Finally, create your custom dialect and register it to Ktorm while creating Database instance.

object CustomDialect : SqlDialect {
    override fun createSqlFormatter(database: Database, beautifySql: Boolean, indentSize: Int): SqlFormatter {
        return CustomFormatter(database, beautifySql, indentSize)
    }
}

val db = Database.connect(
    url = "jdbc:mysql://127.0.0.1:3306/ktorm",
    driver = "com.mysql.jdbc.Driver",
    user = "root",
    dialect = CustomDialect,
    logger = ConsoleLogger(threshold = LogLevel.TRACE)
)

Now you can use the match ... against ... feature, usage:

val employees = Employees.findList { 
    match(it.name, it.job).against("vince", MatchAgainstModifier.IN_NATURAL_LANGUAGE_MODE) 
}

Generated SQL:

select ... 
from t_employee 
left join t_department _ref0 on t_employee.department_id = _ref0.id 
where match (t_employee.name, t_employee.job) against (? in natural language mode)

I hope that would be useful to you. Enjoy Ktorm.

Uh oh!

Uh oh!

mysql match operator #25

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions