1
0
Fork 0

Rewrite video list in raw SQL

This commit is contained in:
Chocobozzz 2020-03-05 15:04:57 +01:00
parent f8cce49c3f
commit 5f3e2425f1
No known key found for this signature in database
GPG key ID: 583A612D890159BE
3 changed files with 428 additions and 434 deletions

View file

@ -156,8 +156,11 @@ function parseAggregateResult (result: any) {
}
const createSafeIn = (model: typeof Model, stringArr: (string | number)[]) => {
return stringArr.map(t => model.sequelize.escape('' + t))
.join(', ')
return stringArr.map(t => {
return t === null
? null
: model.sequelize.escape('' + t)
}).join(', ')
}
function buildLocalAccountIdsIn () {
@ -172,6 +175,21 @@ function buildLocalActorIdsIn () {
)
}
function buildDirectionAndField (value: string) {
let field: string
let direction: 'ASC' | 'DESC'
if (value.substring(0, 1) === '-') {
direction = 'DESC'
field = value.substring(1)
} else {
direction = 'ASC'
field = value
}
return { direction, field }
}
// ---------------------------------------------------------------------------
export {
@ -191,6 +209,7 @@ export {
isOutdated,
parseAggregateResult,
getFollowsSort,
buildDirectionAndField,
createSafeIn
}
@ -203,18 +222,3 @@ function searchTrigramNormalizeValue (value: string) {
function searchTrigramNormalizeCol (col: string) {
return Sequelize.fn('lower', Sequelize.fn('immutable_unaccent', Sequelize.col(col)))
}
function buildDirectionAndField (value: string) {
let field: string
let direction: 'ASC' | 'DESC'
if (value.substring(0, 1) === '-') {
direction = 'DESC'
field = value.substring(1)
} else {
direction = 'ASC'
field = value
}
return { direction, field }
}

View file

@ -0,0 +1,359 @@
import { VideoFilter, VideoPrivacy, VideoState } from '@shared/models'
import { buildDirectionAndField, createSafeIn } from '@server/models/utils'
import { Model } from 'sequelize-typescript'
import { MUserAccountId, MUserId } from '@server/typings/models'
import validator from 'validator'
export type BuildVideosQueryOptions = {
attributes?: string[]
serverAccountId: number
followerActorId: number
includeLocalVideos: boolean
count: number
start: number
sort: string
filter?: VideoFilter
categoryOneOf?: number[]
nsfw?: boolean
licenceOneOf?: number[]
languageOneOf?: string[]
tagsOneOf?: string[]
tagsAllOf?: string[]
withFiles?: boolean
accountId?: number
videoChannelId?: number
videoPlaylistId?: number
trendingDays?: number
user?: MUserAccountId
historyOfUser?: MUserId
startDate?: string // ISO 8601
endDate?: string // ISO 8601
originallyPublishedStartDate?: string
originallyPublishedEndDate?: string
durationMin?: number // seconds
durationMax?: number // seconds
search?: string
isCount?: boolean
group?: string
having?: string
}
function buildListQuery (model: typeof Model, options: BuildVideosQueryOptions) {
const and: string[] = []
const cte: string[] = []
const joins: string[] = []
const replacements: any = {}
let attributes: string[] = options.attributes || [ '"video"."id"' ]
let group = options.group || ''
const having = options.having || ''
joins.push(
'INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId"' +
'INNER JOIN "account" ON "account"."id" = "videoChannel"."accountId"' +
'INNER JOIN "actor" ON "account"."actorId" = "actor"."id"'
)
and.push('"video"."id" NOT IN (SELECT "videoBlacklist"."videoId" FROM "videoBlacklist")')
if (options.serverAccountId) {
const blockerIds = [ options.serverAccountId ]
if (options.user) blockerIds.push(options.user.Account.id)
cte.push(
'"mutedAccount" AS (' +
' SELECT "targetAccountId" AS "id"' +
' FROM "accountBlocklist"' +
' WHERE "accountId" IN (' + createSafeIn(model, blockerIds) + ')' +
' UNION ALL' +
' SELECT "account"."id" AS "id"' +
' FROM account' +
' INNER JOIN "actor" ON account."actorId" = actor.id' +
' INNER JOIN "serverBlocklist" ON "actor"."serverId" = "serverBlocklist"."targetServerId"' +
' WHERE "serverBlocklist"."accountId" IN (' + createSafeIn(model, blockerIds) + ')' +
')'
)
cte.push(
'"mutedChannel" AS (' +
' SELECT "videoChannel"."id"' +
' FROM "videoChannel"' +
' INNER JOIN "mutedAccount" ON "mutedAccount"."id" = "videoChannel"."accountId"' +
' )'
)
and.push(
'"video"."channelId" NOT IN (SELECT "id" FROM "mutedChannel")'
)
replacements.videoChannelId = options.videoChannelId
}
// Only list public/published videos
if (!options.filter || options.filter !== 'all-local') {
and.push(
`("video"."state" = ${VideoState.PUBLISHED} OR ` +
`("video"."state" = ${VideoState.TO_TRANSCODE} AND "video"."waitTranscoding" IS false))`
)
if (options.user) {
and.push(
`("video"."privacy" = ${VideoPrivacy.PUBLIC} OR "video"."privacy" = ${VideoPrivacy.INTERNAL})`
)
} else { // Or only public videos
and.push(
`"video"."privacy" = ${VideoPrivacy.PUBLIC}`
)
}
}
if (options.videoPlaylistId) {
joins.push(
'INNER JOIN "videoPlaylistElement" "video"."id" = "videoPlaylistElement"."videoId" ' +
'AND "videoPlaylistElement"."videoPlaylistId" = :videoPlaylistId'
)
replacements.videoPlaylistId = options.videoPlaylistId
}
if (options.filter && (options.filter === 'local' || options.filter === 'all-local')) {
and.push('"video"."remote" IS FALSE')
}
if (options.accountId) {
and.push('"account"."id" = :accountId')
replacements.accountId = options.accountId
}
if (options.videoChannelId) {
and.push('"videoChannel"."id" = :videoChannelId')
replacements.videoChannelId = options.videoChannelId
}
if (options.followerActorId) {
let query =
'(' +
' EXISTS (' +
' SELECT 1 FROM "videoShare" ' +
' INNER JOIN "actorFollow" "actorFollowShare" ON "actorFollowShare"."targetActorId" = "videoShare"."actorId" ' +
' AND "actorFollowShare"."actorId" = :followerActorId WHERE "videoShare"."videoId" = "video"."id"' +
' )' +
' OR' +
' EXISTS (' +
' SELECT 1 from "actorFollow" ' +
' WHERE "actorFollow"."targetActorId" = "actor"."id" AND "actorFollow"."actorId" = :followerActorId' +
' )'
if (options.includeLocalVideos) {
query += ' OR "video"."remote" IS FALSE'
}
query += ')'
and.push(query)
replacements.followerActorId = options.followerActorId
}
if (options.withFiles === true) {
and.push('EXISTS (SELECT 1 FROM "videoFile" WHERE "videoFile"."videoId" = "video"."id")')
}
if (options.tagsOneOf) {
const tagsOneOfLower = options.tagsOneOf.map(t => t.toLowerCase())
and.push(
'EXISTS (' +
' SELECT 1 FROM "videoTag" ' +
' INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
' WHERE lower("tag"."name") IN (' + createSafeIn(model, tagsOneOfLower) + ') ' +
' AND "video"."id" = "videoTag"."videoId"' +
')'
)
}
if (options.tagsAllOf) {
const tagsAllOfLower = options.tagsAllOf.map(t => t.toLowerCase())
and.push(
'EXISTS (' +
' SELECT 1 FROM "videoTag" ' +
' INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
' WHERE lower("tag"."name") IN (' + createSafeIn(model, tagsAllOfLower) + ') ' +
' AND "video"."id" = "videoTag"."videoId" ' +
' GROUP BY "videoTag"."videoId" HAVING COUNT(*) = ' + tagsAllOfLower.length +
')'
)
}
if (options.nsfw === true) {
and.push('"video"."nsfw" IS TRUE')
}
if (options.nsfw === false) {
and.push('"video"."nsfw" IS FALSE')
}
if (options.categoryOneOf) {
and.push('"video"."category" IN (:categoryOneOf)')
replacements.categoryOneOf = options.categoryOneOf
}
if (options.licenceOneOf) {
and.push('"video"."licence" IN (:licenceOneOf)')
replacements.licenceOneOf = options.licenceOneOf
}
if (options.languageOneOf) {
replacements.languageOneOf = options.languageOneOf.filter(l => l && l !== '_unknown')
let languagesQuery = '("video"."language" IN (:languageOneOf) OR '
if (options.languageOneOf.includes('_unknown')) {
languagesQuery += '"video"."language" IS NULL OR '
}
and.push(
languagesQuery +
' EXISTS (' +
' SELECT 1 FROM "videoCaption" WHERE "videoCaption"."language" ' +
' IN (' + createSafeIn(model, options.languageOneOf) + ') AND ' +
' "videoCaption"."videoId" = "video"."id"' +
' )' +
')'
)
}
// We don't exclude results in this if so if we do a count we don't need to add this complex clauses
if (options.trendingDays && options.isCount !== true) {
const viewsGteDate = new Date(new Date().getTime() - (24 * 3600 * 1000) * options.trendingDays)
joins.push('LEFT JOIN "videoView" ON "video"."id" = "videoView"."videoId" AND "videoView"."startDate" >= :viewsGteDate')
replacements.viewsGteDate = viewsGteDate
group = 'GROUP BY "video"."id"'
}
if (options.historyOfUser) {
joins.push('INNER JOIN "userVideoHistory" on "video"."id" = "userVideoHistory"."videoId"')
and.push('"userVideoHistory"."userId" = :historyOfUser')
replacements.historyOfUser = options.historyOfUser
}
if (options.startDate) {
and.push('"video"."publishedAt" >= :startDate')
replacements.startDate = options.startDate
}
if (options.endDate) {
and.push('"video"."publishedAt" <= :endDate')
replacements.endDate = options.endDate
}
if (options.originallyPublishedStartDate) {
and.push('"video"."originallyPublishedAt" >= :originallyPublishedStartDate')
replacements.originallyPublishedStartDate = options.originallyPublishedStartDate
}
if (options.originallyPublishedEndDate) {
and.push('"video"."originallyPublishedAt" <= :originallyPublishedEndDate')
replacements.originallyPublishedEndDate = options.originallyPublishedEndDate
}
if (options.durationMin) {
and.push('"video"."duration" >= :durationMin')
replacements.durationMin = options.durationMin
}
if (options.durationMax) {
and.push('"video"."duration" <= :durationMax')
replacements.durationMax = options.durationMax
}
if (options.search) {
const escapedSearch = model.sequelize.escape(options.search)
const escapedLikeSearch = model.sequelize.escape('%' + options.search + '%')
let base = '(' +
' lower(immutable_unaccent("video"."name")) % lower(immutable_unaccent(' + escapedSearch + ')) OR ' +
' lower(immutable_unaccent("video"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + ')) OR ' +
' EXISTS (' +
' SELECT 1 FROM "videoTag" ' +
' INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
` WHERE lower("tag"."name") = ${escapedSearch} ` +
' AND "video"."id" = "videoTag"."videoId"' +
' )'
if (validator.isUUID(options.search)) {
base += ` OR "video"."uuid" = ${escapedSearch}`
}
base += ')'
and.push(base)
attributes.push(`similarity(lower(immutable_unaccent("video"."name")), lower(immutable_unaccent(${escapedSearch}))) as similarity`)
} else {
attributes.push('0 as similarity')
}
if (options.isCount === true) attributes = [ 'COUNT(*) as "total"' ]
const cteString = cte.length !== 0
? 'WITH ' + cte.join(', ') + ' '
: ''
let query = cteString +
'SELECT ' + attributes.join(', ') + ' ' +
'FROM "video" ' + joins.join(' ') + ' ' +
'WHERE ' + and.join(' AND ') + ' ' +
group + ' ' +
having + ' '
if (options.isCount !== true) {
const count = parseInt(options.count + '', 10)
const start = parseInt(options.start + '', 10)
query += buildOrder(model, options.sort) + ' ' +
'LIMIT ' + count + ' ' +
'OFFSET ' + start
}
return { query, replacements }
}
function buildOrder (model: typeof Model, value: string) {
const { direction, field } = buildDirectionAndField(value)
if (field.match(/^[a-zA-Z]+$/) === null) throw new Error('Invalid sort column ' + field)
if (field.toLowerCase() === 'random') return 'ORDER BY RANDOM()'
if (field.toLowerCase() === 'trending') { // Sort by aggregation
return `ORDER BY COALESCE(SUM("videoView"."views"), 0) ${direction}, "video"."views" ${direction}`
}
let firstSort: string
if (field.toLowerCase() === 'match') { // Search
firstSort = '"similarity"'
} else {
firstSort = `"video"."${field}"`
}
return `ORDER BY ${firstSort} ${direction}, "video"."id" ASC`
}
export {
buildListQuery
}

View file

@ -1,7 +1,7 @@
import * as Bluebird from 'bluebird'
import { maxBy, minBy } from 'lodash'
import { join } from 'path'
import { CountOptions, FindOptions, IncludeOptions, Op, QueryTypes, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
import { FindOptions, IncludeOptions, Op, QueryTypes, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
import {
AllowNull,
BeforeDestroy,
@ -65,16 +65,7 @@ import { AccountVideoRateModel } from '../account/account-video-rate'
import { ActorModel } from '../activitypub/actor'
import { AvatarModel } from '../avatar/avatar'
import { ServerModel } from '../server/server'
import {
buildBlockedAccountSQL,
buildTrigramSearchIndex,
buildWhereIdOrUUID,
createSafeIn,
createSimilarityAttribute,
getVideoSort,
isOutdated,
throwIfNotValid
} from '../utils'
import { buildTrigramSearchIndex, buildWhereIdOrUUID, getVideoSort, isOutdated, throwIfNotValid } from '../utils'
import { TagModel } from './tag'
import { VideoAbuseModel } from './video-abuse'
import { ScopeNames as VideoChannelScopeNames, SummaryOptions, VideoChannelModel } from './video-channel'
@ -120,7 +111,8 @@ import {
MVideoFormattableDetails,
MVideoForUser,
MVideoFullLight,
MVideoIdThumbnail, MVideoImmutable,
MVideoIdThumbnail,
MVideoImmutable,
MVideoThumbnail,
MVideoThumbnailBlacklist,
MVideoWithAllFiles,
@ -131,8 +123,8 @@ import { MVideoFile, MVideoFileStreamingPlaylistVideo } from '../../typings/mode
import { MThumbnail } from '../../typings/models/video/thumbnail'
import { VideoFile } from '@shared/models/videos/video-file.model'
import { getHLSDirectory, getTorrentFileName, getTorrentFilePath, getVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
import validator from 'validator'
import { ModelCache } from '@server/models/model-cache'
import { buildListQuery, BuildVideosQueryOptions } from './video-query-builder'
export enum ScopeNames {
AVAILABLE_FOR_LIST_IDS = 'AVAILABLE_FOR_LIST_IDS',
@ -241,274 +233,6 @@ export type AvailableForListIDsOptions = {
return query
},
[ScopeNames.AVAILABLE_FOR_LIST_IDS]: (options: AvailableForListIDsOptions) => {
const whereAnd = options.baseWhere ? [].concat(options.baseWhere) : []
const query: FindOptions = {
raw: true,
include: []
}
const attributesType = options.attributesType || 'id'
if (attributesType === 'id') query.attributes = [ 'id' ]
else if (attributesType === 'none') query.attributes = []
whereAnd.push({
id: {
[Op.notIn]: Sequelize.literal(
'(SELECT "videoBlacklist"."videoId" FROM "videoBlacklist")'
)
}
})
if (options.serverAccountId) {
whereAnd.push({
channelId: {
[Op.notIn]: Sequelize.literal(
'(' +
'SELECT id FROM "videoChannel" WHERE "accountId" IN (' +
buildBlockedAccountSQL(options.serverAccountId, options.user ? options.user.Account.id : undefined) +
')' +
')'
)
}
})
}
// Only list public/published videos
if (!options.filter || options.filter !== 'all-local') {
const publishWhere = {
// Always list published videos, or videos that are being transcoded but on which we don't want to wait for transcoding
[Op.or]: [
{
state: VideoState.PUBLISHED
},
{
[Op.and]: {
state: VideoState.TO_TRANSCODE,
waitTranscoding: false
}
}
]
}
whereAnd.push(publishWhere)
// List internal videos if the user is logged in
if (options.user) {
const privacyWhere = {
[Op.or]: [
{
privacy: VideoPrivacy.INTERNAL
},
{
privacy: VideoPrivacy.PUBLIC
}
]
}
whereAnd.push(privacyWhere)
} else { // Or only public videos
const privacyWhere = { privacy: VideoPrivacy.PUBLIC }
whereAnd.push(privacyWhere)
}
}
if (options.videoPlaylistId) {
query.include.push({
attributes: [],
model: VideoPlaylistElementModel.unscoped(),
required: true,
where: {
videoPlaylistId: options.videoPlaylistId
}
})
query.subQuery = false
}
if (options.filter && (options.filter === 'local' || options.filter === 'all-local')) {
whereAnd.push({
remote: false
})
}
if (options.accountId || options.videoChannelId) {
const videoChannelInclude: IncludeOptions = {
attributes: [],
model: VideoChannelModel.unscoped(),
required: true
}
if (options.videoChannelId) {
videoChannelInclude.where = {
id: options.videoChannelId
}
}
if (options.accountId) {
const accountInclude: IncludeOptions = {
attributes: [],
model: AccountModel.unscoped(),
required: true
}
accountInclude.where = { id: options.accountId }
videoChannelInclude.include = [ accountInclude ]
}
query.include.push(videoChannelInclude)
}
if (options.followerActorId) {
let localVideosReq = ''
if (options.includeLocalVideos === true) {
localVideosReq = ' UNION ALL SELECT "video"."id" FROM "video" WHERE remote IS FALSE'
}
// Force actorId to be a number to avoid SQL injections
const actorIdNumber = parseInt(options.followerActorId.toString(), 10)
whereAnd.push({
id: {
[Op.in]: Sequelize.literal(
'(' +
'SELECT "videoShare"."videoId" AS "id" FROM "videoShare" ' +
'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "videoShare"."actorId" ' +
'WHERE "actorFollow"."actorId" = ' + actorIdNumber +
' UNION ALL ' +
'SELECT "video"."id" AS "id" FROM "video" ' +
'INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId" ' +
'INNER JOIN "account" ON "account"."id" = "videoChannel"."accountId" ' +
'INNER JOIN "actor" ON "account"."actorId" = "actor"."id" ' +
'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "actor"."id" ' +
'WHERE "actorFollow"."actorId" = ' + actorIdNumber +
localVideosReq +
')'
)
}
})
}
if (options.withFiles === true) {
whereAnd.push({
id: {
[Op.in]: Sequelize.literal(
'(SELECT "videoId" FROM "videoFile")'
)
}
})
}
// FIXME: issues with sequelize count when making a join on n:m relation, so we just make a IN()
if (options.tagsAllOf || options.tagsOneOf) {
if (options.tagsOneOf) {
const tagsOneOfLower = options.tagsOneOf.map(t => t.toLowerCase())
whereAnd.push({
id: {
[Op.in]: Sequelize.literal(
'(' +
'SELECT "videoId" FROM "videoTag" ' +
'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
'WHERE lower("tag"."name") IN (' + createSafeIn(VideoModel, tagsOneOfLower) + ')' +
')'
)
}
})
}
if (options.tagsAllOf) {
const tagsAllOfLower = options.tagsAllOf.map(t => t.toLowerCase())
whereAnd.push({
id: {
[Op.in]: Sequelize.literal(
'(' +
'SELECT "videoId" FROM "videoTag" ' +
'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
'WHERE lower("tag"."name") IN (' + createSafeIn(VideoModel, tagsAllOfLower) + ')' +
'GROUP BY "videoTag"."videoId" HAVING COUNT(*) = ' + tagsAllOfLower.length +
')'
)
}
})
}
}
if (options.nsfw === true || options.nsfw === false) {
whereAnd.push({ nsfw: options.nsfw })
}
if (options.categoryOneOf) {
whereAnd.push({
category: {
[Op.or]: options.categoryOneOf
}
})
}
if (options.licenceOneOf) {
whereAnd.push({
licence: {
[Op.or]: options.licenceOneOf
}
})
}
if (options.languageOneOf) {
let videoLanguages = options.languageOneOf
if (options.languageOneOf.find(l => l === '_unknown')) {
videoLanguages = videoLanguages.concat([ null ])
}
whereAnd.push({
[Op.or]: [
{
language: {
[Op.or]: videoLanguages
}
},
{
id: {
[Op.in]: Sequelize.literal(
'(' +
'SELECT "videoId" FROM "videoCaption" ' +
'WHERE "language" IN (' + createSafeIn(VideoModel, options.languageOneOf) + ') ' +
')'
)
}
}
]
})
}
if (options.trendingDays) {
query.include.push(VideoModel.buildTrendingQuery(options.trendingDays))
query.subQuery = false
}
if (options.historyOfUser) {
query.include.push({
model: UserVideoHistoryModel,
required: true,
where: {
userId: options.historyOfUser.id
}
})
// Even if the relation is n:m, we know that a user only have 0..1 video history
// So we won't have multiple rows for the same video
// Without this, we would not be able to sort on "updatedAt" column of UserVideoHistoryModel
query.subQuery = false
}
query.where = {
[Op.and]: whereAnd
}
return query
},
[ScopeNames.WITH_THUMBNAILS]: {
include: [
{
@ -1281,25 +1005,21 @@ export class VideoModel extends Model<VideoModel> {
throw new Error('Try to filter all-local but no user has not the see all videos right')
}
const query: FindOptions & { where?: null } = {
offset: options.start,
limit: options.count,
order: getVideoSort(options.sort)
}
let trendingDays: number
if (options.sort.endsWith('trending')) {
trendingDays = CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
query.group = 'VideoModel.id'
}
const trendingDays = options.sort.endsWith('trending')
? CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
: undefined
const serverActor = await getServerActor()
// followerActorId === null has a meaning, so just check undefined
const followerActorId = options.followerActorId !== undefined ? options.followerActorId : serverActor.id
const followerActorId = options.followerActorId !== undefined
? options.followerActorId
: serverActor.id
const queryOptions = {
start: options.start,
count: options.count,
sort: options.sort,
followerActorId,
serverAccountId: serverActor.Account.id,
nsfw: options.nsfw,
@ -1319,7 +1039,7 @@ export class VideoModel extends Model<VideoModel> {
trendingDays
}
return VideoModel.getAvailableForApi(query, queryOptions, options.countVideos)
return VideoModel.getAvailableForApi(queryOptions, options.countVideos)
}
static async searchAndPopulateAccountAndServer (options: {
@ -1343,88 +1063,6 @@ export class VideoModel extends Model<VideoModel> {
user?: MUserAccountId
filter?: VideoFilter
}) {
const whereAnd = []
if (options.startDate || options.endDate) {
const publishedAtRange = {}
if (options.startDate) publishedAtRange[Op.gte] = options.startDate
if (options.endDate) publishedAtRange[Op.lte] = options.endDate
whereAnd.push({ publishedAt: publishedAtRange })
}
if (options.originallyPublishedStartDate || options.originallyPublishedEndDate) {
const originallyPublishedAtRange = {}
if (options.originallyPublishedStartDate) originallyPublishedAtRange[Op.gte] = options.originallyPublishedStartDate
if (options.originallyPublishedEndDate) originallyPublishedAtRange[Op.lte] = options.originallyPublishedEndDate
whereAnd.push({ originallyPublishedAt: originallyPublishedAtRange })
}
if (options.durationMin || options.durationMax) {
const durationRange = {}
if (options.durationMin) durationRange[Op.gte] = options.durationMin
if (options.durationMax) durationRange[Op.lte] = options.durationMax
whereAnd.push({ duration: durationRange })
}
const attributesInclude = []
const escapedSearch = VideoModel.sequelize.escape(options.search)
const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%')
if (options.search) {
const trigramSearch = {
id: {
[Op.in]: Sequelize.literal(
'(' +
'SELECT "video"."id" FROM "video" ' +
'WHERE ' +
'lower(immutable_unaccent("video"."name")) % lower(immutable_unaccent(' + escapedSearch + ')) OR ' +
'lower(immutable_unaccent("video"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))' +
'UNION ALL ' +
'SELECT "video"."id" FROM "video" LEFT JOIN "videoTag" ON "videoTag"."videoId" = "video"."id" ' +
'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
'WHERE lower("tag"."name") = lower(' + escapedSearch + ')' +
')'
)
}
}
if (validator.isUUID(options.search)) {
whereAnd.push({
[Op.or]: [
trigramSearch,
{
uuid: options.search
}
]
})
} else {
whereAnd.push(trigramSearch)
}
attributesInclude.push(createSimilarityAttribute('VideoModel.name', options.search))
}
// Cannot search on similarity if we don't have a search
if (!options.search) {
attributesInclude.push(
Sequelize.literal('0 as similarity')
)
}
const query = {
attributes: {
include: attributesInclude
},
offset: options.start,
limit: options.count,
order: getVideoSort(options.sort)
}
const serverActor = await getServerActor()
const queryOptions = {
followerActorId: serverActor.id,
@ -1438,10 +1076,21 @@ export class VideoModel extends Model<VideoModel> {
tagsAllOf: options.tagsAllOf,
user: options.user,
filter: options.filter,
baseWhere: whereAnd
start: options.start,
count: options.count,
sort: options.sort,
startDate: options.startDate,
endDate: options.endDate,
originallyPublishedStartDate: options.originallyPublishedStartDate,
originallyPublishedEndDate: options.originallyPublishedEndDate,
durationMin: options.durationMin,
durationMax: options.durationMax,
search: options.search
}
return VideoModel.getAvailableForApi(query, queryOptions)
return VideoModel.getAvailableForApi(queryOptions)
}
static load (id: number | string, t?: Transaction): Bluebird<MVideoThumbnail> {
@ -1723,26 +1372,22 @@ export class VideoModel extends Model<VideoModel> {
const serverActor = await getServerActor()
const followerActorId = serverActor.id
const scopeOptions: AvailableForListIDsOptions = {
const queryOptions: BuildVideosQueryOptions = {
attributes: [ `"${field}"` ],
group: `GROUP BY "${field}"`,
having: `HAVING COUNT("${field}") >= ${threshold}`,
start: 0,
sort: 'random',
count,
serverAccountId: serverActor.Account.id,
followerActorId,
includeLocalVideos: true,
attributesType: 'none' // Don't break aggregation
includeLocalVideos: true
}
const query: FindOptions = {
attributes: [ field ],
limit: count,
group: field,
having: Sequelize.where(
Sequelize.fn('COUNT', Sequelize.col(field)), { [Op.gte]: threshold }
),
order: [ (this.sequelize as any).random() ]
}
const { query, replacements } = buildListQuery(VideoModel, queryOptions)
return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST_IDS, scopeOptions ] })
.findAll(query)
.then(rows => rows.map(r => r[field]))
return this.sequelize.query<any>(query, { replacements, type: QueryTypes.SELECT })
.then(rows => rows.map(r => r[field]))
}
static buildTrendingQuery (trendingDays: number) {
@ -1760,34 +1405,21 @@ export class VideoModel extends Model<VideoModel> {
}
private static async getAvailableForApi (
query: FindOptions & { where?: null }, // Forbid where field in query
options: AvailableForListIDsOptions,
options: BuildVideosQueryOptions,
countVideos = true
) {
const idsScope: ScopeOptions = {
method: [
ScopeNames.AVAILABLE_FOR_LIST_IDS, options
]
}
// Remove trending sort on count, because it uses a group by
const countOptions = Object.assign({}, options, { trendingDays: undefined })
const countQuery: CountOptions = Object.assign({}, query, { attributes: undefined, group: undefined })
const countScope: ScopeOptions = {
method: [
ScopeNames.AVAILABLE_FOR_LIST_IDS, countOptions
]
}
const { query, replacements } = buildListQuery(VideoModel, options)
const { query: queryCount, replacements: replacementsCount } = buildListQuery(VideoModel, Object.assign({}, options, { isCount: true }))
const [ count, rows ] = await Promise.all([
countVideos
? VideoModel.scope(countScope).count(countQuery)
? this.sequelize.query<any>(queryCount, { replacements: replacementsCount, type: QueryTypes.SELECT })
.then(rows => rows.length !== 0 ? rows[0].total : 0)
: Promise.resolve<number>(undefined),
VideoModel.scope(idsScope)
.findAll(Object.assign({}, query, { raw: true }))
this.sequelize.query<any>(query, { replacements, type: QueryTypes.SELECT })
.then(rows => rows.map(r => r.id))
.then(ids => VideoModel.loadCompleteVideosForApi(ids, query, options))
.then(ids => VideoModel.loadCompleteVideosForApi(ids, options))
])
return {
@ -1796,13 +1428,12 @@ export class VideoModel extends Model<VideoModel> {
}
}
private static loadCompleteVideosForApi (ids: number[], query: FindOptions, options: AvailableForListIDsOptions) {
private static loadCompleteVideosForApi (ids: number[], options: BuildVideosQueryOptions) {
if (ids.length === 0) return []
const secondQuery: FindOptions = {
offset: 0,
limit: query.limit,
attributes: query.attributes,
limit: options.count,
order: [ // Keep original order
Sequelize.literal(
ids.map(id => `"VideoModel".id = ${id} DESC`).join(', ')