Mercurial Hosting > luan

comparison lucene/src/luan/modules/lucene/LuceneSearcher.java @ 233:ef39bc4d3f70

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
basic lucene works git-svn-id: https://luan-java.googlecode.com/svn/trunk@234 21e917c8-12df-6dd8-5cb6-c86387c605b9
author fschmidt@gmail.com <fschmidt@gmail.com@21e917c8-12df-6dd8-5cb6-c86387c605b9>
date Thu, 02 Oct 2014 02:58:55 +0000
parents 9ce18106f95a
children b25feac318d8
comparison
equal deleted inserted replaced
232:9ce18106f95a 233:ef39bc4d3f70
23 import luan.LuanJavaFunction; 23 import luan.LuanJavaFunction;
24 import luan.LuanException; 24 import luan.LuanException;
25 25
26 26
27 public final class LuceneSearcher { 27 public final class LuceneSearcher {
28 private final LuceneIndex index;
28 private final IndexSearcher searcher; 29 private final IndexSearcher searcher;
29 30
30 LuceneSearcher(IndexReader reader) { 31 LuceneSearcher(LuceneIndex index,IndexReader reader) {
32 this.index = index;
31 this.searcher = new IndexSearcher(reader); 33 this.searcher = new IndexSearcher(reader);
32 } 34 }
33 35
34 // call in finally block 36 // call in finally block
35 void close() { 37 void close() throws IOException {
36 try { 38 searcher.getIndexReader().decRef();
37 searcher.getIndexReader().decRef();
38 } catch(IOException e) {
39 throw new RuntimeException(e);
40 }
41 } 39 }
42 40
43 public LuanTable doc(int docID) throws IOException { 41 LuanTable doc(LuanState luan,int docID) throws LuanException, IOException {
44 return LuceneDocument.toTable(searcher.doc(docID)); 42 return index.toTable(luan,searcher.doc(docID));
45 } 43 }
46 44
47 TopDocs search(Query query,int n) throws IOException { 45 TopDocs search(Query query,int n) throws IOException {
48 return searcher.search(query,n); 46 return searcher.search(query,n);
49 } 47 }
52 return searcher.search(query,n,sort); 50 return searcher.search(query,n,sort);
53 } 51 }
54 52
55 // luan 53 // luan
56 54
57 private Query termQuery(Map<Object,Object> map) { 55 private Query termQuery(LuanTable queryTbl) {
56 if( queryTbl.length() != 0 )
57 return null;
58 Map<Object,Object> map = queryTbl.asMap();
58 if( map.size() != 1 ) 59 if( map.size() != 1 )
59 return null; 60 return null;
60 Map.Entry<Object,Object> entry = map.entrySet().iterator().next(); 61 Map.Entry<Object,Object> entry = map.entrySet().iterator().next();
61 Object key = entry.getKey(); 62 Object key = entry.getKey();
62 Object value = entry.getValue(); 63 Object value = entry.getValue();
63 if( key instanceof String && value instanceof String ) { 64 if( key instanceof String && value instanceof String ) {
64 return new TermQuery(new Term( (String)key, (String)value )); 65 return new TermQuery(index.newTerm( (String)key, (String)value ));
65 } 66 }
66 return null; 67 return null;
67 } 68 }
68 69
69 private Query booleanQuery(Map<Object,Object> map) { 70 private Query booleanQuery(LuanTable queryTbl) {
71 if( !queryTbl.isList() )
72 return null;
73 List<Object> clauses = queryTbl.asList();
70 BooleanQuery query = new BooleanQuery(); 74 BooleanQuery query = new BooleanQuery();
71 for( Map.Entry<Object,Object> entry : map.entrySet() ) { 75 for( Object obj : clauses ) {
72 Object key = entry.getKey(); 76 if( !(obj instanceof LuanTable) )
73 Object value = entry.getValue();
74 if( !(key instanceof String && value instanceof LuanTable) )
75 return null; 77 return null;
76 Query subQuery = query( (LuanTable)value ); 78 LuanTable tbl = (LuanTable)obj;
77 if( subQuery == null ) 79 if( !(tbl.isList() && tbl.length()==2) )
80 return null;
81 List<Object> list = tbl.asList();
82 Object obj0 = list.get(0);
83 Object obj1 = list.get(1);
84 if( !(obj0 instanceof String && obj1 instanceof LuanTable) )
78 return null; 85 return null;
79 BooleanClause.Occur occur; 86 BooleanClause.Occur occur;
80 try { 87 try {
81 occur = BooleanClause.Occur.valueOf( ((String)key).toUpperCase() ); 88 occur = BooleanClause.Occur.valueOf( ((String)obj0).toUpperCase() );
82 } catch(IllegalArgumentException e) { 89 } catch(IllegalArgumentException e) {
83 return null; 90 return null;
84 } 91 }
92 Query subQuery = query( (LuanTable)obj1 );
93 if( subQuery == null )
94 return null;
85 query.add(subQuery,occur); 95 query.add(subQuery,occur);
86 } 96 }
87 return query; 97 return query;
88 } 98 }
89 99
90 private Query query(LuanTable queryTbl) { 100 private Query query(LuanTable queryTbl) {
91 Map<Object,Object> map = queryTbl.asMap(); 101 if( queryTbl.isEmpty() )
92 if( map.isEmpty() )
93 return null; 102 return null;
94 Query query; 103 Query query;
95 query = termQuery(map); if(query!=null) return query; 104 query = termQuery(queryTbl); if(query!=null) return query;
96 query = booleanQuery(map); if(query!=null) return query; 105 query = booleanQuery(queryTbl); if(query!=null) return query;
97 return null; 106 return null;
98 } 107 }
99 108
100 private SortField sortField(LuanState luan,List<Object> list,String pos) throws LuanException { 109 private SortField sortField(LuanState luan,List<Object> list,String pos) throws LuanException {
101 int size = list.size(); 110 int size = list.size();
104 Object obj0 = list.get(0); 113 Object obj0 = list.get(0);
105 Object obj1 = list.get(1); 114 Object obj1 = list.get(1);
106 if( !(obj0 instanceof String && obj1 instanceof String) ) 115 if( !(obj0 instanceof String && obj1 instanceof String) )
107 throw luan.exception("invalid sort field"+pos); 116 throw luan.exception("invalid sort field"+pos);
108 String field = (String)obj0; 117 String field = (String)obj0;
118 field = index.fixFieldName(field);
109 SortField.Type type; 119 SortField.Type type;
110 try { 120 try {
111 type = SortField.Type.valueOf( ((String)obj1).toUpperCase() ); 121 type = SortField.Type.valueOf( ((String)obj1).toUpperCase() );
112 } catch(IllegalArgumentException e) { 122 } catch(IllegalArgumentException e) {
113 throw luan.exception("invalid sort field type"+pos); 123 throw luan.exception("invalid sort field type"+pos);
114 } 124 }
115 if( size == 2 ) 125 if( size == 2 )
116 return new SortField(field,type); 126 return new SortField(field,type);
117 Object obj2 = list.get(2); 127 Object obj2 = list.get(2);
118 if( !(obj2 instanceof Boolean) ) 128 if( !(obj2 instanceof String) )
119 throw luan.exception("invalid sort field"+pos+", 'reverse' must be boolean"); 129 throw luan.exception("invalid sort field"+pos+", order must be 'ascending' or 'descending'");
120 boolean reverse = (Boolean)obj2; 130 String order = (String)obj2;
121 return new SortField(field,type,reverse); 131 if( !(order.equals("ascending") || order.equals("descending")) )
132 throw luan.exception("invalid sort field"+pos+", order must be 'ascending' or 'descending'");
133 return new SortField( field, type, order.equals("descending") );
122 } 134 }
123 135
124 private Sort sort(LuanState luan,LuanTable sortTbl) throws LuanException { 136 private Sort sort(LuanState luan,LuanTable sortTbl) throws LuanException {
125 if( !sortTbl.isList() ) 137 if( !sortTbl.isList() )
126 throw luan.exception("invalid sort, must be list"); 138 throw luan.exception("invalid sort, must be list");
153 165
154 @Override public Object call(LuanState luan,Object[] args) throws LuanException { 166 @Override public Object call(LuanState luan,Object[] args) throws LuanException {
155 if( i >= scoreDocs.length ) 167 if( i >= scoreDocs.length )
156 return LuanFunction.NOTHING; 168 return LuanFunction.NOTHING;
157 try { 169 try {
158 LuanTable doc = doc(scoreDocs[i++].doc); 170 LuanTable doc = doc(luan,scoreDocs[i++].doc);
159 return doc; 171 return doc;
160 } catch(IOException e) { 172 } catch(IOException e) {
161 throw luan.exception(e); 173 throw luan.exception(e);
162 } 174 }
163 } 175 }