001    package railo.runtime.query;
002    
003    import java.util.Iterator;
004    import java.util.Map.Entry;
005    
006    import railo.runtime.PageContext;
007    import railo.runtime.dump.DumpData;
008    import railo.runtime.dump.DumpProperties;
009    import railo.runtime.exp.DatabaseException;
010    import railo.runtime.exp.PageException;
011    import railo.runtime.exp.PageRuntimeException;
012    import railo.runtime.type.Collection;
013    import railo.runtime.type.KeyImpl;
014    import railo.runtime.type.QueryColumn;
015    import railo.runtime.type.Sizeable;
016    import railo.runtime.type.dt.DateTime;
017    import railo.runtime.type.util.QueryUtil;
018    
019    public class QueryCacheQueryColumn implements QueryColumn,Sizeable {
020    
021            private QueryCacheQuery qcq;
022            private QueryColumn column;
023            private Collection.Key key;
024    
025            
026            /**
027             * return a queryCacheQuery
028             * @param qcq
029             * @param key
030             * @return
031             * @throws DatabaseException
032             */
033            public static QueryColumn getColumn(QueryCacheQuery qcq, Key key) throws DatabaseException {
034                    QueryColumn _column = qcq.getQuery().getColumn(key);
035                    return new QueryCacheQueryColumn(qcq,_column,key);
036            }
037            
038            /**
039             * return a queryCacheQuery
040             * @param qcq
041             * @param key
042             * @param defaultValue
043             * @return
044             */
045            public static QueryColumn getColumn(QueryCacheQuery qcq, Key key, QueryColumn defaultValue) {
046                    QueryColumn _column = qcq.getQuery().getColumn(key,null);
047                    if(_column==null) return defaultValue;
048                    return new QueryCacheQueryColumn(qcq,_column,key);
049            }
050    
051            /**
052             * Constructor of the class
053             * @param qcq
054             * @param column
055             * @param key
056             */
057            private QueryCacheQueryColumn(QueryCacheQuery qcq, QueryColumn column, Key key) {
058                    this.qcq=qcq;
059                    this.column=column;
060                    this.key=key;
061            }
062    
063            private void disconnectCache() {
064                    qcq.disconnectCache();
065                    try {
066                            column=qcq.getQuery().getColumn(key);
067                    } catch (DatabaseException e) {
068                            throw new PageRuntimeException(e);
069                    }
070            }
071    
072            @Override
073            public void add(Object value) {
074                    disconnectCache();
075                    column.add(value);
076            }
077    
078            @Override
079            public void addRow(int count) {
080                    disconnectCache();
081                    column.addRow(count);
082            }
083    
084            @Override
085            public void cutRowsTo(int maxrows) {
086                    disconnectCache();
087                    column.cutRowsTo(maxrows);
088            }
089    
090            @Override
091            public Object get(int row) throws PageException {
092                    return column.get(row);
093            }
094    
095            @Override
096            public Object get(int row, Object defaultValue) {
097                    return column.get(row, defaultValue);
098            }
099    
100            @Override
101            public int getType() {
102                    return column.getType();
103            }
104    
105            @Override
106            public String getTypeAsString() {
107                    return column.getTypeAsString();
108            }
109    
110            @Override
111            public Object remove(int row) throws PageException {
112                    disconnectCache();
113                    return column.remove(row);
114            }
115    
116            @Override
117            public Object removeEL(int row) {
118                    disconnectCache();
119                    return column.removeEL(row);
120            }
121    
122            @Override
123            public Object removeRow(int row) throws PageException {
124                    disconnectCache();
125                    return column.removeRow(row);
126            }
127    
128            @Override
129            public Object set(int row, Object value) throws PageException {
130                    disconnectCache();
131                    return column.set(row, value);
132            }
133    
134            @Override
135            public Object setEL(int row, Object value) {
136                    disconnectCache();
137                    return column.setEL(row, value);
138            }
139    
140            @Override
141            public void clear() {
142                    disconnectCache();
143                    column.clear();
144            }
145    
146            @Override
147            public boolean containsKey(String key) {
148                    return column.containsKey(key);
149            }
150    
151            @Override
152            public boolean containsKey(Key key) {
153                    return column.containsKey(key);
154            }
155    
156            @Override
157            public Collection duplicate(boolean deepCopy) {
158                    return column.duplicate(deepCopy);
159            }
160            
161    
162            @Override
163            public Object get(String key) throws PageException {
164                    return get(KeyImpl.init(key));
165            }
166    
167            @Override
168            public Object get(Key key) throws PageException {
169                    return column.get(key);
170            }
171    
172            @Override
173            public Object get(String key, Object defaultValue) {
174                    return column.get(key, defaultValue);
175            }
176    
177            @Override
178            public Object get(Key key, Object defaultValue) {
179                    return column.get(key, defaultValue);
180            }
181    
182            @Override
183            public Key[] keys() {
184                    return column.keys();
185            }
186    
187            @Override
188            public Object remove(Key key) throws PageException {
189                    disconnectCache();
190                    return column.remove(key);
191            }
192    
193    
194            @Override
195            public Object removeEL(Key key) {
196                    disconnectCache();
197                    return column.removeEL(key);
198            }
199    
200            @Override
201            public Object set(String key, Object value) throws PageException {
202                    disconnectCache();
203                    return column.set(key, value);
204            }
205    
206            @Override
207            public Object set(Key key, Object value) throws PageException {
208                    disconnectCache();
209                    return column.set(key, value);
210            }
211    
212            @Override
213            public Object setEL(String key, Object value) {
214                    disconnectCache();
215                    return column.setEL(key, value);
216            }
217    
218            @Override
219            public Object setEL(Key key, Object value) {
220                    disconnectCache();
221                    return column.setEL(key, value);
222            }
223    
224            @Override
225            public int size() {
226                    return column.size();
227            }
228    
229            @Override
230            public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties dp) {
231                    return column.toDumpData(pageContext, maxlevel,dp);
232            }
233    
234            @Override
235            public Iterator<Collection.Key> keyIterator() {
236                    return column.keyIterator();
237            }
238        
239        @Override
240            public Iterator<String> keysAsStringIterator() {
241            return column.keysAsStringIterator();
242        }
243            
244            @Override
245            public Iterator<Entry<Key, Object>> entryIterator() {
246                    return column.entryIterator();
247            }
248    
249            @Override
250            public boolean castToBooleanValue() throws PageException {
251                    return column.castToBooleanValue();
252            }
253        
254        @Override
255        public Boolean castToBoolean(Boolean defaultValue) {
256            return column.castToBoolean(defaultValue);
257        }
258    
259            @Override
260            public DateTime castToDateTime() throws PageException {
261                    return column.castToDateTime();
262            }
263        
264        @Override
265        public DateTime castToDateTime(DateTime defaultValue) {
266            return column.castToDateTime(defaultValue);
267        }
268    
269            @Override
270            public double castToDoubleValue() throws PageException {
271                    return column.castToDoubleValue();
272            }
273        
274        @Override
275        public double castToDoubleValue(double defaultValue) {
276            return column.castToDoubleValue(defaultValue);
277        }
278    
279            @Override
280            public String castToString() throws PageException {
281                    return column.castToString();
282            }
283    
284            @Override
285            public String castToString(String defaultValue) {
286                    return column.castToString(defaultValue);
287            }
288    
289            @Override
290            public int compareTo(String str) throws PageException {
291                    return column.compareTo(str);
292            }
293    
294            @Override
295            public int compareTo(boolean b) throws PageException {
296                    return column.compareTo(b);
297            }
298    
299            @Override
300            public int compareTo(double d) throws PageException {
301                    return column.compareTo(d);
302            }
303    
304            @Override
305            public int compareTo(DateTime dt) throws PageException {
306                    return column.compareTo(dt);
307            }
308    
309            @Override
310            public Object get(PageContext pc) throws PageException {
311                    return column.get(pc);
312            }
313    
314            @Override
315            public Object get(PageContext pc, Object defaultValue) {
316                    return column.get(pc, defaultValue);
317            }
318    
319            @Override
320            public Key getKey() throws PageException {
321                    return column.getKey();
322            }
323    
324            @Override
325            public String getKeyAsString() throws PageException {
326                    return column.getKeyAsString();
327            }
328    
329            @Override
330            public Object getParent() {
331                    return qcq;
332            }
333    
334            @Override
335            public Object remove(PageContext pc) throws PageException {
336                    disconnectCache();
337                    return column.remove(pc);
338            }
339    
340            @Override
341            public Object removeEL(PageContext pc) {
342                    disconnectCache();
343                    return column.removeEL(pc);
344            }
345    
346            @Override
347            public Object set(PageContext pc, Object value) throws PageException {
348                    disconnectCache();
349                    return column.set(pc, value);
350            }
351    
352            @Override
353            public Object setEL(PageContext pc, Object value) {
354                    disconnectCache();
355                    return column.setEL(pc, value);
356            }
357    
358            @Override
359            public Object touch(PageContext pc) throws PageException {
360                    disconnectCache();
361                    return column.touch(pc);
362            }
363    
364            @Override
365            public Object touchEL(PageContext pc) {
366                    disconnectCache();
367                    return column.touchEL(pc);
368            }
369    
370            @Override
371            public Object clone() {
372                    return column.clone();
373            }
374    
375            @Override
376            public Iterator<Object> valueIterator() {
377                    return column.valueIterator();
378            }
379            
380    
381    
382            @Override
383            public long sizeOf() {
384                    return QueryUtil.sizeOf(column);
385            }
386            
387            @Override
388            public java.util.Iterator<String> getIterator() {
389            return keysAsStringIterator();
390        }
391    }