use std::{any::TypeId, sync::Arc};
use anyhow::{Result, ensure};
use diesel::expression::{AppearsOnTable, SelectableExpression, ValidGrouping, is_aggregate::No};
use diesel::pg::Pg;
use diesel::query_builder::{AstPass, QueryFragment, QueryId};
use diesel::sql_types::{Bool, Nullable, Text};
use diesel::{Column, Expression, QueryResult};
use crate::{
diesel_helpers::Predicate,
ranking::RankingSignal,
search::{SearchKind, SearchTerm},
};
#[derive(diesel::sql_types::SqlType, diesel::query_builder::QueryId)]
#[diesel(postgres_type(name = "tsvector"))]
pub struct TsVector;
mod sealed {
pub trait TextTarget {}
pub trait VectorTarget {}
}
impl sealed::TextTarget for Text {}
impl sealed::TextTarget for Nullable<Text> {}
impl sealed::VectorTarget for TsVector {}
impl sealed::VectorTarget for Nullable<TsVector> {}
pub trait TextTarget: sealed::TextTarget {}
impl<T: sealed::TextTarget> TextTarget for T {}
pub trait VectorTarget: sealed::VectorTarget {}
impl<T: sealed::VectorTarget> VectorTarget for T {}
pub fn text<C>(
column: C,
configuration: &'static str,
value: &SearchTerm,
) -> Result<Predicate<C::Table>>
where
C: Column + QueryFragment<Pg> + Send + 'static,
C::SqlType: TextTarget,
{
predicate(column, configuration, value, Target::Text)
}
pub fn vector<C>(
column: C,
configuration: &'static str,
value: &SearchTerm,
) -> Result<Predicate<C::Table>>
where
C: Column + QueryFragment<Pg> + Send + 'static,
C::SqlType: VectorTarget,
{
predicate(column, configuration, value, Target::Vector)
}
pub fn text_query<C>(
column: C,
configuration: &'static str,
value: &SearchTerm,
) -> Result<crate::ranking::CompiledQueryFilter<C::Table>>
where
C: Column + Copy + QueryFragment<Pg> + Send + 'static,
C::SqlType: TextTarget,
{
ranked(column, configuration, value, Target::Text)
}
pub fn vector_query<C>(
column: C,
configuration: &'static str,
value: &SearchTerm,
) -> Result<crate::ranking::CompiledQueryFilter<C::Table>>
where
C: Column + Copy + QueryFragment<Pg> + Send + 'static,
C::SqlType: VectorTarget,
{
ranked(column, configuration, value, Target::Vector)
}
fn ranked<C>(
column: C,
configuration: &'static str,
value: &SearchTerm,
target: Target,
) -> Result<crate::ranking::CompiledQueryFilter<C::Table>>
where
C: Column + Copy + QueryFragment<Pg> + Send + 'static,
{
use crate::ranking::Direction;
let search = Search::new(column, configuration, value, target)?;
let key = Arc::clone(&search.key);
let mut signal = RankingSignal::new(
"relevance",
Rank(search.clone()),
Direction::Descending,
"postgres.full_text",
);
signal.provenance = Some(key);
Ok(crate::compiler::QueryFilter {
predicate: Box::new(search),
signals: vec![signal],
})
}
struct Rank<C>(Search<C>);
impl<C> Expression for Rank<C> {
type SqlType = diesel::sql_types::Float;
}
impl<C: Column> AppearsOnTable<C::Table> for Rank<C> {}
impl<C: Column> SelectableExpression<C::Table> for Rank<C> {}
impl<C> ValidGrouping<()> for Rank<C> {
type IsAggregate = No;
}
impl<C> QueryId for Rank<C> {
type QueryId = ();
const HAS_STATIC_QUERY_ID: bool = false;
}
impl<C: QueryFragment<Pg>> QueryFragment<Pg> for Rank<C> {
fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
out.unsafe_to_cache_prepared();
out.push_sql("COALESCE(ts_rank_cd(");
self.0.target(out.reborrow())?;
out.push_sql(", ");
self.0.tsquery(out.reborrow())?;
out.push_sql("), 0.0::real)");
Ok(())
}
}
fn predicate<C>(
column: C,
configuration: &'static str,
value: &SearchTerm,
target: Target,
) -> Result<Predicate<C::Table>>
where
C: Column + QueryFragment<Pg> + Send + 'static,
{
Ok(Box::new(Search::new(column, configuration, value, target)?))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Target {
Text,
Vector,
}
#[derive(Debug, PartialEq, Eq, Hash)]
struct SearchKey {
column: TypeId,
configuration: &'static str,
query: String,
kind: SearchKind,
target: Target,
}
#[derive(Clone)]
struct Search<C> {
column: C,
key: Arc<SearchKey>,
}
impl<C: 'static> Search<C> {
fn new(
column: C,
configuration: &'static str,
value: &SearchTerm,
target: Target,
) -> Result<Self> {
ensure!(
!configuration.is_empty()
&& configuration
.bytes()
.all(|c| c.is_ascii_alphanumeric() || c == b'_' || c == b'.'),
"text-search configuration must be a static, optionally schema-qualified ASCII name"
);
if value.kind == SearchKind::Prefix {
SearchTerm::prefix(&value.text)?;
}
Ok(Self {
column,
key: Arc::new(SearchKey {
column: TypeId::of::<C>(),
configuration,
query: value.text.clone(),
kind: value.kind,
target,
}),
})
}
}
impl<C> Expression for Search<C> {
type SqlType = Bool;
}
impl<C: Column> AppearsOnTable<C::Table> for Search<C> {}
impl<C: Column> SelectableExpression<C::Table> for Search<C> {}
impl<C> ValidGrouping<()> for Search<C> {
type IsAggregate = No;
}
impl<C> QueryId for Search<C> {
type QueryId = ();
const HAS_STATIC_QUERY_ID: bool = false;
}
impl<C: QueryFragment<Pg>> Search<C> {
fn target<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
if self.key.target == Target::Text {
out.push_sql("to_tsvector('");
out.push_sql(self.key.configuration);
out.push_sql("'::regconfig, ");
}
self.column.walk_ast(out.reborrow())?;
if self.key.target == Target::Text {
out.push_sql(")");
}
Ok(())
}
fn tsquery<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
if self.key.kind == SearchKind::Prefix {
out.push_sql("(SELECT COALESCE(string_agg(chr(39) || replace(replace(lexeme, chr(92), chr(92) || chr(92)), chr(39), chr(39) || chr(39)) || chr(39) || ':*', ' & ' ORDER BY lexeme), '')::tsquery FROM unnest(tsvector_to_array(to_tsvector('");
out.push_sql(self.key.configuration);
out.push_sql("'::regconfig, ");
out.push_bind_param::<Text, _>(&self.key.query)?;
out.push_sql("))) AS aip160_prefix(lexeme))");
} else {
out.push_sql(if self.key.kind == SearchKind::Phrase {
"phraseto_tsquery('"
} else {
"plainto_tsquery('"
});
out.push_sql(self.key.configuration);
out.push_sql("'::regconfig, ");
out.push_bind_param::<Text, _>(&self.key.query)?;
out.push_sql(")");
}
Ok(())
}
}
impl<C: QueryFragment<Pg>> QueryFragment<Pg> for Search<C> {
fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
out.unsafe_to_cache_prepared();
out.push_sql("(");
self.target(out.reborrow())?;
out.push_sql(" @@ ");
self.tsquery(out.reborrow())?;
out.push_sql(")");
Ok(())
}
}
struct BestTextScore(Vec<crate::ranking::ErasedExpression>);
impl QueryFragment<Pg> for BestTextScore {
fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
out.push_sql("GREATEST(");
for (i, e) in self.0.iter().enumerate() {
if i != 0 {
out.push_sql(", ");
}
e.walk_ast(out.reborrow())?;
}
out.push_sql(")");
Ok(())
}
}
#[doc(hidden)]
pub(super) fn finish_signals<T>(signals: Vec<RankingSignal<T>>) -> Vec<RankingSignal<T>> {
let mut result = Vec::new();
let mut keys = std::collections::HashSet::new();
let mut text: Option<RankingSignal<T>> = None;
let mut expressions = Vec::new();
for signal in signals {
let key = signal
.provenance
.as_ref()
.and_then(|data| Arc::clone(data).downcast::<SearchKey>().ok());
if let Some(key) = key {
if keys.insert(key) {
if text.is_none() {
text = Some(signal);
} else {
expressions.push(signal.expression);
}
}
} else {
result.push(signal);
}
}
if let Some(mut signal) = text {
if !expressions.is_empty() {
expressions.insert(0, signal.expression);
signal.expression = Box::new(BestTextScore(expressions));
}
signal.provenance = None;
result.push(signal);
}
result
}