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

public static Field textField2 = new Field(TEXT_FIELD_2_KEY, FIELD_2_TEXT, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);

public static final String FIELD_3_TEXT = "aaaNoNorms aaaNoNorms bbbNoNorms";

public static final String TEXT_FIELD_3_KEY = "textField3";

public static Field textField3 = new Field(TEXT_FIELD_3_KEY, FIELD_3_TEXT, Field.Store.YES, Field.Index.ANALYZED);

static { textField3.setOmitNorms(true); }

public static final String KEYWORD_TEXT = "Keyword";

public static final String KEYWORD_FIELD_KEY = "keyField";

public static Field keyField = new Field(KEYWORD_FIELD_KEY, KEYWORD_TEXT,

Field.Store.YES, Field.Index.NOT_ANALYZED);

public static final String NO_NORMS_TEXT = "omitNormsText";

public static final String NO_NORMS_KEY = "omitNorms";

public static Field noNormsField = new Field(NO_NORMS_KEY, NO_NORMS_TEXT,

Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS);

public static final String NO_TF_TEXT = "analyzed with no tf and positions";

public static final String NO_TF_KEY = "omitTermFreqAndPositions";

public static Field noTFField = new Field(NO_TF_KEY, NO_TF_TEXT,

Field.Store.YES, Field.Index.ANALYZED);

static {

noTFField.setIndexOptions(IndexOptions.DOCS_ONLY);

}

public static final String UNINDEXED_FIELD_TEXT = "unindexed field text";

public static final String UNINDEXED_FIELD_KEY = "unIndField";

public static Field unIndField = new Field(UNINDEXED_FIELD_KEY, UNINDEXED_FIELD_TEXT,

Field.Store.YES, Field.Index.NO);

public static final String UNSTORED_1_FIELD_TEXT = "unstored field text";

public static final String UNSTORED_FIELD_1_KEY = "unStoredField1";

public static Field unStoredField1 = new Field(UNSTORED_FIELD_1_KEY, UNSTORED_1_FIELD_TEXT,

Field.Store.NO, Field.Index.ANALYZED, Field.TermVector.NO);

public static final String UNSTORED_2_FIELD_TEXT = "unstored field text";

public static final String UNSTORED_FIELD_2_KEY = "unStoredField2";

public static Field unStoredField2 = new Field(UNSTORED_FIELD_2_KEY, UNSTORED_2_FIELD_TEXT,

Field.Store.NO, Field.Index.ANALYZED, Field.TermVector.YES);

public static final String LAZY_FIELD_BINARY_KEY = "lazyFieldBinary";

public static byte [] LAZY_FIELD_BINARY_BYTES;

public static Field lazyFieldBinary;

public static final String LAZY_FIELD_KEY = "lazyField";

public static final String LAZY_FIELD_TEXT = "These are some field bytes";

100

public static Field lazyField = new Field(LAZY_FIELD_KEY, LAZY_FIELD_TEXT, Field.Store.YES, Field.Index.ANALYZED);

101

102

public static final String LARGE_LAZY_FIELD_KEY = "largeLazyField";

103

public static String LARGE_LAZY_FIELD_TEXT;

104

public static Field largeLazyField;

105

106

//From Issue 509

107

public static final String FIELD_UTF1_TEXT = "field one \u4e00text";

108

public static final String TEXT_FIELD_UTF1_KEY = "textField1Utf8";

109

public static Field textUtfField1 = new Field(TEXT_FIELD_UTF1_KEY, FIELD_UTF1_TEXT,

110

Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.NO);

111

112

public static final String FIELD_UTF2_TEXT = "field field field \u4e00two text";

113

//Fields will be lexicographically sorted. So, the order is: field, text, two

114

public static final int [] FIELD_UTF2_FREQS = {3, 1, 1};

115

public static final String TEXT_FIELD_UTF2_KEY = "textField2Utf8";

116

public static Field textUtfField2 = new Field(TEXT_FIELD_UTF2_KEY, FIELD_UTF2_TEXT, Field.Store.YES,

117

Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);

118

119

120

121

122

public static Map<String,Object> nameValues = null;

123

124

// ordered list of all the fields...

125

// could use LinkedHashMap for this purpose if Java1.4 is OK

126

public static Field[] fields = new Field[] {

127

textField1,

128

textField2,

129

textField3,

130

keyField,

131

noNormsField,

132

noTFField,

133

unIndField,

134

unStoredField1,

135

unStoredField2,

136

textUtfField1,

137

textUtfField2,

138

lazyField,

139

lazyFieldBinary,//placeholder for binary field, since this is null. It must be second to last.

140

largeLazyField//placeholder for large field, since this is null. It must always be last

141

};

142

143

public static Map<String,Fieldable> all =new HashMap<String,Fieldable>();

144

public static Map<String,Fieldable> indexed =new HashMap<String,Fieldable>();

145

public static Map<String,Fieldable> stored =new HashMap<String,Fieldable>();

146

public static Map<String,Fieldable> unstored=new HashMap<String,Fieldable>();

147

public static Map<String,Fieldable> unindexed=new HashMap<String,Fieldable>();

148

public static Map<String,Fieldable> termvector=new HashMap<String,Fieldable>();

149

public static Map<String,Fieldable> notermvector=new HashMap<String,Fieldable>();

150

public static Map<String,Fieldable> lazy= new HashMap<String,Fieldable>();

151

public static Map<String,Fieldable> noNorms=new HashMap<String,Fieldable>();

152

public static Map<String,Fieldable> noTf=new HashMap<String,Fieldable>();

153

154

static {

155

//Initialize the large Lazy Field

156

StringBuilder buffer = new StringBuilder();

157

for (int i = 0; i < 10000; i++)

158

{

159

buffer.append("Lazily loading lengths of language in lieu of laughing ");

160

}

161

162

try {

163

LAZY_FIELD_BINARY_BYTES = "These are some binary field bytes".getBytes("UTF8");

164

} catch (UnsupportedEncodingException e) {

165

}

166

lazyFieldBinary = new Field(LAZY_FIELD_BINARY_KEY, LAZY_FIELD_BINARY_BYTES);

167

fields[fields.length - 2] = lazyFieldBinary;

168

LARGE_LAZY_FIELD_TEXT = buffer.toString();

169

largeLazyField = new Field(LARGE_LAZY_FIELD_KEY, LARGE_LAZY_FIELD_TEXT, Field.Store.YES, Field.Index.ANALYZED);

170

fields[fields.length - 1] = largeLazyField;

171

for (int i=0; i<fields.length; i++) {

172

Fieldable f = fields[i];

173

add(all,f);

174

if (f.isIndexed()) add(indexed,f);

175

else add(unindexed,f);

176

if (f.isTermVectorStored()) add(termvector,f);

177

if (f.isIndexed() && !f.isTermVectorStored()) add(notermvector,f);

178

if (f.isStored()) add(stored,f);

179

else add(unstored,f);

180

if (f.getOmitNorms()) add(noNorms,f);

181

if (f.getIndexOptions() == IndexOptions.DOCS_ONLY) add(noTf,f);

182

if (f.isLazy()) add(lazy, f);

183

}

184

}

185

186

187

private static void add(Map<String,Fieldable> map, Fieldable field) {

188

map.put(field.name(), field);

189

}

190

191

192

static

193

{

194

nameValues = new HashMap<String,Object>();

195

nameValues.put(TEXT_FIELD_1_KEY, FIELD_1_TEXT);

196

nameValues.put(TEXT_FIELD_2_KEY, FIELD_2_TEXT);

197

nameValues.put(TEXT_FIELD_3_KEY, FIELD_3_TEXT);

198

nameValues.put(KEYWORD_FIELD_KEY, KEYWORD_TEXT);

199

nameValues.put(NO_NORMS_KEY, NO_NORMS_TEXT);

200

nameValues.put(NO_TF_KEY, NO_TF_TEXT);

201

nameValues.put(UNINDEXED_FIELD_KEY, UNINDEXED_FIELD_TEXT);

202

nameValues.put(UNSTORED_FIELD_1_KEY, UNSTORED_1_FIELD_TEXT);

203

nameValues.put(UNSTORED_FIELD_2_KEY, UNSTORED_2_FIELD_TEXT);

204

nameValues.put(LAZY_FIELD_KEY, LAZY_FIELD_TEXT);

205

nameValues.put(LAZY_FIELD_BINARY_KEY, LAZY_FIELD_BINARY_BYTES);

206

nameValues.put(LARGE_LAZY_FIELD_KEY, LARGE_LAZY_FIELD_TEXT);

207

nameValues.put(TEXT_FIELD_UTF1_KEY, FIELD_UTF1_TEXT);

208

nameValues.put(TEXT_FIELD_UTF2_KEY, FIELD_UTF2_TEXT);

209

}

210

211

/**

212

* Adds the fields above to a document

213

* @param doc The document to write

214

215

public static void setupDoc(Document doc) {

216

for (int i=0; i<fields.length; i++) {

217

doc.add(fields[i]);

218

}

219

}

220

221

/**

222

* Writes the document to the directory using a segment

223

* named "test"; returns the SegmentInfo describing the new

224

* segment

225

* @param dir

226

* @param doc

227

* @throws IOException

228

229

public static SegmentInfo writeDoc(Random random, Directory dir, Document doc) throws IOException

230

{

231

return writeDoc(random, dir, new MockAnalyzer(random, MockTokenizer.WHITESPACE, false), null, doc);

232

}

233

234

/**

235

* Writes the document to the directory using the analyzer

236

* and the similarity score; returns the SegmentInfo

237

* describing the new segment

238

* @param dir

239

* @param analyzer

240

* @param similarity

241

* @param doc

242

* @throws IOException

243

244

public static SegmentInfo writeDoc(Random random, Directory dir, Analyzer analyzer, Similarity similarity, Document doc) throws IOException {

245

IndexWriter writer = new IndexWriter(dir, new IndexWriterConfig( /* LuceneTestCase.newIndexWriterConfig(random, */

246

TEST_VERSION_CURRENT, analyzer).setSimilarity(similarity));

247

//writer.setUseCompoundFile(false);

248

writer.addDocument(doc);

249

writer.commit();

250

SegmentInfo info = writer.newestSegment();

251

writer.close();

252

return info;

253

}

254

255

public static int numFields(Document doc) {

256

return doc.getFields().size();

257

}

258

259

public static Document createDocument(int n, String indexName, int numFields) {

260

StringBuilder sb = new StringBuilder();

261

Document doc = new Document();

262

doc.add(new Field("id", Integer.toString(n), Store.YES, Index.NOT_ANALYZED, TermVector.WITH_POSITIONS_OFFSETS));

263

doc.add(new Field("indexname", indexName, Store.YES, Index.NOT_ANALYZED, TermVector.WITH_POSITIONS_OFFSETS));

264

sb.append("a");

265

sb.append(n);

266

doc.add(new Field("field1", sb.toString(), Store.YES, Index.ANALYZED, TermVector.WITH_POSITIONS_OFFSETS));

267

sb.append(" b");

268

sb.append(n);

269

for (int i = 1; i < numFields; i++) {

270

doc.add(new Field("field" + (i + 1), sb.toString(), Store.YES,

271

Index.ANALYZED, TermVector.WITH_POSITIONS_OFFSETS));

272

}

273

return doc;

274

}

275

}

Older »