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 }