~slub.team/goobi-indexserver/3.x

assertTrue("Cached DocIdSet must be an FixedBitSet if the original one was not cacheable (got " + cachedSet + ")", cachedSet instanceof FixedBitSet || cachedSet == DocIdSet.EMPTY_DOCIDSET);

122

}

123

}

124

125

public void testIsCacheAble() throws Exception {

126

Directory dir = newDirectory();

127

RandomIndexWriter writer = new RandomIndexWriter(random, dir);

128

writer.addDocument(new Document());

129

writer.close();

130

131

IndexReader reader = IndexReader.open(dir, true);

132

133

// not cacheable:

134

assertDocIdSetCacheable(reader, new QueryWrapperFilter(new TermQuery(new Term("test","value"))), false);

135

// returns default empty docidset, always cacheable:

136

assertDocIdSetCacheable(reader, NumericRangeFilter.newIntRange("test", Integer.valueOf(10000), Integer.valueOf(-10000), true, true), true);

137

// is cacheable:

138

assertDocIdSetCacheable(reader, FieldCacheRangeFilter.newIntRange("test", Integer.valueOf(10), Integer.valueOf(20), true, true), true);

139

// a fixedbitset filter is always cacheable

140

assertDocIdSetCacheable(reader, new Filter() {

141

@Override

142

public DocIdSet getDocIdSet(IndexReader reader) {

143

return new FixedBitSet(reader.maxDoc());

144

}

145

}, true);

146

147

reader.close();

148

dir.close();

149

}

150

151

public void testEnforceDeletions() throws Exception {

152

Directory dir = newDirectory();

153

RandomIndexWriter writer = new RandomIndexWriter(

154

random,

155

dir,

156

newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).

157

setMergeScheduler(new SerialMergeScheduler()).

158

// asserts below requires no unexpected merges:

159

setMergePolicy(newLogMergePolicy(10))

160

);

161

162

// NOTE: cannot use writer.getReader because RIW (on

163

// flipping a coin) may give us a newly opened reader,

164

// but we use .reopen on this reader below and expect to

165

// (must) get an NRT reader:

166

IndexReader reader = IndexReader.open(writer.w, true);

167

// same reason we don't wrap?

168

IndexSearcher searcher = newSearcher(reader, false);

169

170

// add a doc, refresh the reader, and check that its there

171

Document doc = new Document();

172

doc.add(newField("id", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));

173

writer.addDocument(doc);

174

175

reader = refreshReader(reader);

176

searcher.close();

177

searcher = newSearcher(reader, false);

178

179

TopDocs docs = searcher.search(new MatchAllDocsQuery(), 1);

180

assertEquals("Should find a hit...", 1, docs.totalHits);

181

182

final Filter startFilter = new QueryWrapperFilter(new TermQuery(new Term("id", "1")));

183

184

// ignore deletions

185

CachingWrapperFilter filter = new CachingWrapperFilter(startFilter, CachingWrapperFilter.DeletesMode.IGNORE);

186

187

docs = searcher.search(new MatchAllDocsQuery(), filter, 1);

188

assertEquals("[query + filter] Should find a hit...", 1, docs.totalHits);

189

ConstantScoreQuery constantScore = new ConstantScoreQuery(filter);

190

docs = searcher.search(constantScore, 1);

191

assertEquals("[just filter] Should find a hit...", 1, docs.totalHits);

192

193

// now delete the doc, refresh the reader, and see that it's not there

194

_TestUtil.keepFullyDeletedSegments(writer.w);

195

writer.deleteDocuments(new Term("id", "1"));

196

197

reader = refreshReader(reader);

198

searcher.close();

199

searcher = newSearcher(reader, false);

200

201

docs = searcher.search(new MatchAllDocsQuery(), filter, 1);

202

assertEquals("[query + filter] Should *not* find a hit...", 0, docs.totalHits);

203

204

docs = searcher.search(constantScore, 1);

205

assertEquals("[just filter] Should find a hit...", 1, docs.totalHits);

206

207

208

// force cache to regenerate:

209

filter = new CachingWrapperFilter(startFilter, CachingWrapperFilter.DeletesMode.RECACHE);

210

211

writer.addDocument(doc);

212

213

reader = refreshReader(reader);

214

searcher.close();

215

searcher = newSearcher(reader, false);

216

217

docs = searcher.search(new MatchAllDocsQuery(), filter, 1);

218

219

assertEquals("[query + filter] Should find a hit...", 1, docs.totalHits);

220

221

constantScore = new ConstantScoreQuery(filter);

222

docs = searcher.search(constantScore, 1);

223

assertEquals("[just filter] Should find a hit...", 1, docs.totalHits);

224

225

// NOTE: important to hold ref here so GC doesn't clear

226

// the cache entry! Else the assert below may sometimes

227

// fail:

228

IndexReader oldReader = reader;

229

230

// make sure we get a cache hit when we reopen reader

231

// that had no change to deletions

232

// Deletes nothing:

233

writer.deleteDocuments(new Term("foo", "bar"));

234

reader = refreshReader(reader);

235

assertTrue(reader == oldReader);

236

int missCount = filter.missCount;

237

docs = searcher.search(constantScore, 1);

238

assertEquals("[just filter] Should find a hit...", 1, docs.totalHits);

239

assertEquals(missCount, filter.missCount);

240

241

// now delete the doc, refresh the reader, and see that it's not there

242

writer.deleteDocuments(new Term("id", "1"));

243

244

reader = refreshReader(reader);

245

searcher.close();

246

searcher = newSearcher(reader, false);

247

248

missCount = filter.missCount;

249

docs = searcher.search(new MatchAllDocsQuery(), filter, 1);

250

assertEquals(missCount+1, filter.missCount);

251

assertEquals("[query + filter] Should *not* find a hit...", 0, docs.totalHits);

252

docs = searcher.search(constantScore, 1);

253

assertEquals("[just filter] Should *not* find a hit...", 0, docs.totalHits);

254

255

256

// apply deletions dynamically

257

filter = new CachingWrapperFilter(startFilter, CachingWrapperFilter.DeletesMode.DYNAMIC);

258

259

writer.addDocument(doc);

260

reader = refreshReader(reader);

261

searcher.close();

262

searcher = newSearcher(reader, false);

263

264

docs = searcher.search(new MatchAllDocsQuery(), filter, 1);

265

assertEquals("[query + filter] Should find a hit...", 1, docs.totalHits);

266

constantScore = new ConstantScoreQuery(filter);

267

docs = searcher.search(constantScore, 1);

268

assertEquals("[just filter] Should find a hit...", 1, docs.totalHits);

269

270

// now delete the doc, refresh the reader, and see that it's not there

271

writer.deleteDocuments(new Term("id", "1"));

272

273

reader = refreshReader(reader);

274

searcher.close();

275

searcher = newSearcher(reader, false);

276

277

docs = searcher.search(new MatchAllDocsQuery(), filter, 1);

278

assertEquals("[query + filter] Should *not* find a hit...", 0, docs.totalHits);

279

280

missCount = filter.missCount;

281

docs = searcher.search(constantScore, 1);

282

assertEquals("[just filter] Should *not* find a hit...", 0, docs.totalHits);

283

284

// doesn't count as a miss

285

assertEquals(missCount, filter.missCount);

286

287

// NOTE: silliness to make sure JRE does not optimize

288

// away our holding onto oldReader to prevent

289

// CachingWrapperFilter's WeakHashMap from dropping the

290

// entry:

291

assertTrue(oldReader != null);

292

293

searcher.close();

294

reader.close();

295

writer.close();

296

dir.close();

297

}

298

299

private static IndexReader refreshReader(IndexReader reader) throws IOException {

300

IndexReader oldReader = reader;

301

reader = reader.reopen();

302

if (reader != oldReader) {

303

oldReader.close();

304

}

305

return reader;

306

}

307

}

Older »