1 package com.daffodilwoods.daffodildb.server.sql99.expression.booleanvalueexpression; 2 3 import java.util.*; 4 5 import com.daffodilwoods.daffodildb.server.datasystem.indexsystem.*; 6 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*; 7 import com.daffodilwoods.daffodildb.server.sql99.common.*; 8 import com.daffodilwoods.daffodildb.server.sql99.dql.execution.*; 9 import com.daffodilwoods.daffodildb.server.sql99.dql.plan.condition.*; 10 import com.daffodilwoods.daffodildb.server.sql99.dql.plan.table.*; 11 import com.daffodilwoods.daffodildb.server.sql99.expression.booleanvalueexpression.predicates.*; 12 import com.daffodilwoods.daffodildb.server.sql99.expression.rowvalueexpression.*; 13 import com.daffodilwoods.daffodildb.server.sql99.token.*; 14 import com.daffodilwoods.daffodildb.server.sql99.utils.*; 15 import com.daffodilwoods.database.resource.*; 16 import com.daffodilwoods.database.sqlinitiator.*; 17 18 32 33 public class booleantermSRESERVEDWORD1206543922booleanfactor extends AbstractBooleanValueExpression implements booleanterm, ExecutionPlanConstants, JoinConditionTableGetter ,_SingleTableCondition{ 34 public booleanfactor _booleanfactor0; 35 public SRESERVEDWORD1206543922 _SRESERVEDWORD12065439221; 36 public booleanterm _booleanterm2; 37 38 public booleantermSRESERVEDWORD1206543922booleanfactor() { 39 } 40 41 public booleantermSRESERVEDWORD1206543922booleanfactor(booleanterm obj1, booleanfactor obj2, SRESERVEDWORD1206543922 reservedWord) { 42 _booleanfactor0 = (booleanfactor) obj2; 43 _booleanterm2 = (booleanterm) obj1; 44 _SRESERVEDWORD12065439221 = reservedWord; 45 } 46 47 public booleantermSRESERVEDWORD1206543922booleanfactor(booleanterm obj1, booleanfactor obj2) { 48 _booleanfactor0 = (booleanfactor) obj2; 49 _booleanterm2 = (booleanterm) obj1; 50 } 51 52 60 61 public double getCost(long rowCount, boolean index) throws DException { 62 long rowsReduced = _booleanterm2.getEstimatedRows(rowCount); 63 return _booleanterm2.getCost(rowCount, index) + _booleanfactor0.getCost(rowsReduced, index); 64 } 65 66 80 81 public _QualifiedBVE getQualifiedBVE(TableDetails[] tableDetails0) throws DException { 82 _QualifiedBVE qBve1 = _booleanterm2.getQualifiedBVE(tableDetails0); 83 _QualifiedBVE qBve2 = _booleanfactor0.getQualifiedBVE(tableDetails0); 84 _BVESingleTablePlan[] bveSingleTablePlan1 = (BVESingleTablePlan[]) qBve1.getBVESingleTablePlans(); 85 _BVESingleTablePlan[] bveSingleTablePlan2 = (BVESingleTablePlan[]) qBve2.getBVESingleTablePlans(); 86 booleanvalueexpression resultantOnCondition = BVEPlanMerger.addAndConditions(qBve1.getOnCondition(), qBve2.getOnCondition()); 87 if (bveSingleTablePlan1 == null) { 88 return (bveSingleTablePlan2 == null) ? new QualifiedBVE(null, this) : new QualifiedBVE(bveSingleTablePlan2, resultantOnCondition); 89 } 90 if (bveSingleTablePlan2 == null) { 91 return new QualifiedBVE(bveSingleTablePlan1, resultantOnCondition); 92 } 93 int length1 = bveSingleTablePlan1.length; 94 int length2 = bveSingleTablePlan2.length; 95 ArrayList aList = new ArrayList(length2); 96 for (int i = 0; i < length2; i++) { 97 boolean found = false; 98 _BVESingleTablePlan bveSingleTablePlan = bveSingleTablePlan2[i]; 99 TableDetails tableDetails = bveSingleTablePlan.getTableDetails()[0]; 100 for (int j = 0; j < length1; j++) { 101 if (tableDetails == bveSingleTablePlan1[j].getTableDetails()[0]) { 102 bveSingleTablePlan1[j] = BVEPlanMerger.mergeSameSinglePlanWithAnd(bveSingleTablePlan1[j], bveSingleTablePlan); 103 found = true; 104 break; 105 } 106 } 107 if (!found) { 108 aList.add(bveSingleTablePlan); 109 } 110 } 111 int size = aList.size(); 112 QualifiedBVE resultant = null; 113 if (size != 0) { 114 BVESingleTablePlan[] stp = new BVESingleTablePlan[bveSingleTablePlan1.length + size]; 115 BVESingleTablePlan[] stp1 = (BVESingleTablePlan[]) aList.toArray(new BVESingleTablePlan[aList.size()]); 116 System.arraycopy(bveSingleTablePlan1, 0, stp, 0, bveSingleTablePlan1.length); 117 System.arraycopy(stp1, 0, stp, bveSingleTablePlan1.length, stp1.length); 118 resultant = new QualifiedBVE(stp, resultantOnCondition); 119 } else { 120 resultant = new QualifiedBVE(bveSingleTablePlan1, resultantOnCondition); 121 } 122 return resultant; 123 } 124 125 133 134 public int canUseForSeek() throws DException { 135 int leftSeekableValue = _booleanterm2.canUseForSeek(); 136 int rightseekableValue = _booleanfactor0.canUseForSeek(); 137 switch(leftSeekableValue){ 138 case TypeConstants.BOTHSIDESEEKABLE: 139 switch(rightseekableValue){ 140 case TypeConstants.BOTHSIDESEEKABLE: 141 case TypeConstants.LEFTSIDESEEKABLE: 142 case TypeConstants.RIGHTSIDESEEKABLE: 143 case TypeConstants.NOSEEK: 144 return TypeConstants.BOTHSIDESEEKABLE; 145 default: 146 throw new DException("DSE0",new Object [] {"IN CanUseForSeek Invalid Case"}); } 148 149 case TypeConstants.LEFTSIDESEEKABLE: 150 switch(rightseekableValue){ 151 case TypeConstants.BOTHSIDESEEKABLE: 152 case TypeConstants.LEFTSIDESEEKABLE: 153 case TypeConstants.RIGHTSIDESEEKABLE: 154 return TypeConstants.BOTHSIDESEEKABLE; 155 case TypeConstants.NOSEEK: 156 return TypeConstants.LEFTSIDESEEKABLE; 157 default: 158 throw new DException("DSE0",new Object [] {"IN CanUseForSeek Invalid Case"}); } 160 case TypeConstants.RIGHTSIDESEEKABLE: 161 switch(rightseekableValue){ 162 case TypeConstants.BOTHSIDESEEKABLE: 163 case TypeConstants.LEFTSIDESEEKABLE: 164 case TypeConstants.RIGHTSIDESEEKABLE: 165 return TypeConstants.BOTHSIDESEEKABLE; 166 case TypeConstants.NOSEEK: 167 return TypeConstants.RIGHTSIDESEEKABLE; 168 default: 169 throw new DException("DSE0",new Object [] {"IN CanUseForSeek Invalid Case"}); } 171 case TypeConstants.NOSEEK: 172 return TypeConstants.NOSEEK; 173 default: 174 throw new DException("DSE0",new Object [] {"IN CanUseForSeek Invalid Case"}); 176 } 177 } 178 179 233 234 242 243 244 245 public void setColumnPredicates(_AllColumnPredicates allColumnPredicates) throws DException { 246 _booleanterm2.setColumnPredicates(allColumnPredicates); 247 _booleanfactor0.setColumnPredicates(allColumnPredicates); 248 } 249 250 273 274 public _IndexPredicateInterface getCost(_Order order, String [] queryColumns, Object session, TableDetails tableDetail, ColumnDetails[] aggregateColumns) throws DException { 275 AllColumnPredicates allColumnPredicate = initializeAllColumnPredicate(tableDetail); 276 return calculateCost(order, queryColumns, session, tableDetail, allColumnPredicate, aggregateColumns); 277 } 278 279 private IndexPredicate calculateCost(_Order order, String [] queryColumns, Object session, TableDetails tableDetail, AllColumnPredicates allColumnPredicate, ColumnDetails[] aggregateColumns) throws DException { 280 IndexPredicate resultantIndexPredicate = null; 281 _IndexInformation[] indexInformation = ( (_IndexTable) session).getIndexInformations(); 282 ColumnDetails aggColumn = aggregateColumns == null ? null : aggregateColumns[0].getExistingColumnDetails()[0]; 283 for (int i = 0; i < indexInformation.length; ++i) { 284 IndexPredicate indexPredicate = (IndexPredicate) allColumnPredicate.splitForIndex(indexInformation[i], i); 285 indexPredicate.setTableDetails(tableDetail); 286 if (TableReferenceMerger.checkForAggregateColumn(aggColumn, indexInformation[i])) { 287 double cost = CostCalculator.computeCostForIndex(indexPredicate, session, order, queryColumns, indexInformation[i], i); 288 indexPredicate.setCost(cost); 289 if (aggColumn != null) { 290 indexPredicate.setIndex(i); 291 } 292 resultantIndexPredicate = checkForMinimum(indexPredicate, resultantIndexPredicate); 293 } 294 } 295 if (resultantIndexPredicate.getOrder() == null && order != null) { 296 order.setSolvableByIndex(true); 297 } 298 return resultantIndexPredicate; 299 } 300 301 private AllColumnPredicates initializeAllColumnPredicate(TableDetails tableDetail) throws DException { 302 AllColumnPredicates allColumnPredicate = new AllColumnPredicates(); 303 allColumnPredicate.setTableDetails(tableDetail); 304 _booleanterm2.setColumnPredicates(allColumnPredicate); 305 _booleanfactor0.setColumnPredicates(allColumnPredicate); 306 return allColumnPredicate; 307 } 308 309 private IndexPredicate checkForMinimum(IndexPredicate indexPredicate1, IndexPredicate indexPredicate2) throws DException { 310 if (indexPredicate2 == null) { 311 return indexPredicate1; 312 } 313 double comingCost = indexPredicate1.getCost(); 314 double inCost = indexPredicate2.getCost(); 315 return inCost > comingCost 316 ? indexPredicate1 : indexPredicate2; 317 } 318 319 public int getConditionType() throws DException { 320 return BTANDBF; 321 } 322 323 335 336 public _BVEPlan getExecutionPlan() throws DException { 337 _BVEPlan tablePlan1 = _booleanterm2.getExecutionPlan(); 338 _BVEPlan tablePlan2 = _booleanfactor0.getExecutionPlan(); 339 _BVEPlan resultantPlan = BVEPlanMerger.mergeTablePlansWithAnd(tablePlan1, tablePlan2); 340 return resultantPlan; 341 } 342 343 359 360 public Object run(Object object) throws DException { 361 Object result1 = _booleanterm2.run(object); 362 if (result1.hashCode() == 0) { 363 return _booleanfactor0.run(object); 364 } 365 Object result2 = null; 366 if (result1.hashCode() == -2) { result2 = _booleanfactor0.run(object); 368 return result2.hashCode() == 0 ? result1 : predicate.boolResultWithLeftSign[result2.hashCode() + 2][1]; 369 } else if (result1.hashCode() == 2) { 370 result2 = _booleanfactor0.run(object); 371 return result2.hashCode() == 0 ? result1 : predicate.boolResultWithLeftSign[result2.hashCode() + 2][0]; 372 } 373 return result1; 374 } 375 376 383 384 public ParameterInfo[] getParameterInfo() throws DException { 385 ParameterInfo[] parameterInfo1 = _booleanterm2.getParameterInfo(); 386 ParameterInfo[] parameterInfo2 = _booleanfactor0.getParameterInfo(); 387 return GeneralPurposeStaticClass.getCombinedParameterInfoArray(parameterInfo1, parameterInfo2); 388 } 389 390 397 398 public TableDetails[] getCorrespondingTablesInvolved(TableDetails[] td) throws com.daffodilwoods.database.resource.DException { 399 ArrayList toRet = new ArrayList(); 400 boolean found = false; 401 TableDetails[] td1 = null, td2 = null; 402 if (_booleanterm2 instanceof JoinConditionTableGetter) { 403 td1 = ( (JoinConditionTableGetter) _booleanterm2).getCorrespondingTablesInvolved(td); 404 if (td1 != null) { 405 toRet.addAll(Arrays.asList(td1)); 406 found = true; 407 } 408 } 409 if (_booleanfactor0 instanceof JoinConditionTableGetter) { 410 td2 = ( (JoinConditionTableGetter) _booleanfactor0).getCorrespondingTablesInvolved(td); 411 if (td2 != null) { 412 toRet.addAll(Arrays.asList(td2)); 413 found = true; 414 } 415 } 416 if (found) { 417 return (TableDetails[]) toRet.toArray(new TableDetails[0]); 418 } 419 return null; 420 } 421 422 427 428 public void verifyValues(_VariableValueOperations vv) throws DException { 429 if (_booleanfactor0 instanceof JoinConditionTableGetter) { 430 ( (JoinConditionTableGetter) _booleanfactor0).verifyValues(vv); 431 } 432 if (_booleanterm2 instanceof JoinConditionTableGetter) { 433 ( (JoinConditionTableGetter) _booleanfactor0).verifyValues(vv); 434 } 435 } 436 437 442 443 public AbstractRowValueExpression[] getChilds() { 444 AbstractRowValueExpression[] childs = new AbstractRowValueExpression[] { (AbstractRowValueExpression) (_booleanterm2), (AbstractRowValueExpression) (_booleanfactor0)}; 445 return childs; 446 } 447 448 457 458 public boolean isNullPredicate() throws DException { 459 return _booleanterm2.isNullPredicate() || _booleanfactor0.isNullPredicate(); 460 } 461 462 469 470 public long getEstimatedRows(long noOfRows) throws DException { 471 long rowCount = _booleanterm2.getEstimatedRows(noOfRows); 472 return _booleanfactor0.getEstimatedRows(rowCount); 473 } 474 475 public String toString() { 476 StringBuffer sb = new StringBuffer (); 477 sb.append(" "); 478 sb.append(_booleanterm2); 479 sb.append(" "); 480 sb.append(_SRESERVEDWORD12065439221); 481 sb.append(" "); 482 sb.append(_booleanfactor0); 483 return sb.toString(); 484 } 485 486 public Object clone() throws CloneNotSupportedException { 487 booleantermSRESERVEDWORD1206543922booleanfactor tempClass = new booleantermSRESERVEDWORD1206543922booleanfactor(); 488 tempClass._booleanfactor0 = (booleanfactor) _booleanfactor0.clone(); 489 tempClass._SRESERVEDWORD12065439221 = (SRESERVEDWORD1206543922) _SRESERVEDWORD12065439221.clone(); 490 tempClass._booleanterm2 = (booleanterm) _booleanterm2.clone(); 491 try { 492 tempClass.getColumnDetails(); 493 } catch (DException ex) { 494 throw new RuntimeException (ex.getMessage()); 495 } 496 return tempClass; 497 } 498 499 public booleanvalueexpression getSingleTableCondition() throws DException { 500 if (checkForMultipleTables()) { 501 booleanvalueexpression bve1 = null; 502 if (_booleanterm2 instanceof _SingleTableCondition) { 503 ((_SingleTableCondition)_booleanterm2).getSingleTableCondition(); 504 } else { 505 throw new DException("DSE0", new Object [] {"Not handled the condition " + _booleanterm2.getClass()}); 506 } 507 booleanvalueexpression bve2 = _booleanfactor0.getSingleTableCondition(); 508 return BVEPlanMerger.addAndConditions(bve1, bve2); 509 } 510 return this; 511 } 512 513 } 514 | Popular Tags |