1 package com.daffodilwoods.daffodildb.server.sql99.dql.iterator.table; 2 3 import java.util.*; 4 5 import com.daffodilwoods.daffodildb.client.*; 6 import com.daffodilwoods.daffodildb.server.sql99.common.*; 7 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.*; 8 import com.daffodilwoods.daffodildb.server.sql99.utils.*; 9 import com.daffodilwoods.daffodildb.utils.field.*; 10 import com.daffodilwoods.database.resource.*; 11 import com.daffodilwoods.database.sqlinitiator.*; 12 import com.daffodilwoods.database.utility.P; 13 import com.daffodilwoods.daffodildb.server.sql99.dql.execution._OrderCount; 14 import com.daffodilwoods.daffodildb.server.sql99.dql.execution.OrderCount; 15 import com.daffodilwoods.daffodildb.utils.field.FieldBase; 16 import java.math.BigDecimal ; 17 import com.daffodilwoods.daffodildb.utils.byteconverter.CCzufDpowfsufs; 18 19 20 37 38 public class JoinIterator extends BaseJoinIterator { 39 40 43 _Reference[] leftColumnReferences; 44 48 private Object [][] tableDetailsMapping; 49 53 private int leftCount = -1; 59 private int leftKeyCount = 0; 60 65 private int rightKeyCount = 0; 66 69 private TableDetails[] leftTableDetails = null; 70 73 private TableDetails[] rightTableDetails = null; 74 75 82 public JoinIterator(_Iterator leftIterator, _Iterator rightIterator, _Reference[] columnReferences, ColumnDetails[] hasRecordReferences0) { 83 super(leftIterator, rightIterator, hasRecordReferences0); 84 leftColumnReferences = columnReferences; 85 if (leftColumnReferences == null || leftColumnReferences.length == 0) { 86 Thread.dumpStack(); 87 } 88 state = INVALIDSTATE; 89 } 90 91 105 121 public boolean first() throws DException { 122 if (!leftIterator.first()) { 123 state = AFTERLAST; 124 return false; 125 } 126 getAndSetConditionValues(); 127 while (!rightIterator.first()) { 128 if (!leftIterator.next()) { 129 state = AFTERLAST; 130 return false; 131 } 132 getAndSetConditionValues(); 133 } 134 state = VALIDSTATE; 135 return true; 136 } 137 138 154 public boolean last() throws DException { 155 if (!leftIterator.last()) { 156 state = BEFOREFIRST; 157 return false; 158 } 159 160 getAndSetConditionValues(); 161 while (!rightIterator.last()) { 162 if (!leftIterator.previous()) { 163 state = BEFOREFIRST; 164 return false; 165 } 166 getAndSetConditionValues(); 167 } 168 state = VALIDSTATE; 169 return true; 170 } 171 172 190 public boolean next() throws DException { 191 switch (state) { 192 case INVALIDSTATE: 193 throw new DException("DSE4116", null); 194 case AFTERLAST: 195 return false; 196 case BEFOREFIRST: 197 return first(); 198 default: { 199 boolean left = rightIterator.next(); 200 if (!left) { 201 do { 202 if (!leftIterator.next()) { 203 state = AFTERLAST; 204 return false; 205 } 206 getAndSetConditionValues(); 207 left = rightIterator.first(); 208 } while (!left); 209 } 210 state = VALIDSTATE; 211 return true; 212 } 213 } 214 } 215 216 234 public boolean previous() throws DException { 235 switch (state) { 236 case INVALIDSTATE: 237 throw new DException("DSE4117", null); 238 case AFTERLAST: 239 return last(); 240 case BEFOREFIRST: 241 return false; 242 default: { 243 boolean right = rightIterator.previous(); 244 if (!right) { 245 do { 246 if (!leftIterator.previous()) { 247 state = BEFOREFIRST; 248 return false; 249 } 250 getAndSetConditionValues(); 251 right = rightIterator.last(); 252 } while (!right); 253 } 254 state = VALIDSTATE; 255 return true; 256 } 257 } 258 } 259 260 266 public byte[] getByteKey() throws DException { 267 byte[] leftKeys =leftIterator.getByteKey(); 268 byte[] rightKeys = rightIterator.getByteKey(); 269 byte[] resultantKeys=new byte[leftKeys.length+rightKeys.length+4]; 270 short leftLength = (short)leftKeys.length; 271 System.arraycopy(CCzufDpowfsufs.getBytes(leftLength),0,resultantKeys,0,2); 272 System.arraycopy(leftKeys,0,resultantKeys,2,leftKeys.length); 273 System.arraycopy(rightKeys,0,resultantKeys,leftKeys.length+2,rightKeys.length); 274 return resultantKeys; 275 } 276 277 285 public void moveByteKey(byte[] key) throws DException { 286 if(leftKeyCount != 0 || rightKeyCount !=0 ){ 287 moveAcctoGroupByteKey(key); 288 return; 289 } 290 byte[] leftKeys = new byte[CCzufDpowfsufs.getShortValue(key,0)]; 291 System.arraycopy(key,2,leftKeys,0,leftKeys.length); 292 leftIterator.moveByteKey(leftKeys); 293 getAndSetConditionValues(); 294 byte[] rightKeys = new byte[key.length-leftKeys.length-2]; 295 System.arraycopy(key,leftKeys.length+2,rightKeys,0,rightKeys.length); 296 rightIterator.moveByteKey(rightKeys); 297 state=VALIDSTATE; 298 299 } 300 301 302 309 private void moveAcctoGroupByteKeyold(byte[] keys,int leftTdCount,int rightTdCount) throws DException { 310 int k=0; 311 int[] t=null; 312 if (leftKeyCount == 0) 313 leftIterator.first(); 314 else{ 315 t=getLegthOfArray(keys,leftTdCount,rightTdCount,0); 316 byte[] leftKeys =new byte[t[0]]; 317 for(int j=0;j<leftTdCount;j++){ 318 leftKeys[k] =(byte) keys[k]; 319 System.arraycopy(keys,k+1,leftKeys,k+1,keys[0]); 320 k+=keys[k]; 321 } 322 leftIterator.move(leftKeys); 323 } 324 getAndSetConditionValues(); 325 if (rightKeyCount == 0) 326 rightIterator.first(); 327 else{ 328 int rightKeysLength = 0; 329 byte[] rightKeys =new byte[t[1]]; 330 for(int j=0;j<rightTdCount;j++){ 331 rightKeys[k] =(byte) keys[k]; 332 System.arraycopy(keys,1,rightKeys,k+1,keys[0]); 333 k+=keys[k]; 334 } 335 rightIterator.move(rightKeys); 336 337 } 338 state = VALIDSTATE; 339 } 340 341 352 private void moveAcctoGroupByteKey(byte[] keys) throws DException { 353 int index =0; 354 if (leftKeyCount == 0) 355 leftIterator.first(); 356 else{ 357 index = moveBytes(leftTableDetails,leftIterator,index,keys); 358 } 359 getAndSetConditionValues(); 360 if (rightKeyCount == 0) 361 rightIterator.first(); 362 else{ 363 index = moveBytes(rightTableDetails ,rightIterator,index,keys); 364 } 365 state = VALIDSTATE; 366 } 367 368 377 private int moveBytes(TableDetails[] td,_Iterator iter,int index,byte[] keys) throws DException{ 378 byte[] temp; 379 int length = 0; 380 for (int j = 0; j < td.length; j++) { 381 length += CCzufDpowfsufs.getShortValue(keys,index); 382 index = length + 2; 383 } 384 byte[] resultantKeys = new byte[length]; 385 System.arraycopy(keys, 0, resultantKeys, 0, resultantKeys.length); 386 iter.move(resultantKeys); 387 return index; 388 } 389 390 398 private int[] getLegthOfArray(byte[] keys, int lefTdCount, int rightTdCount, 399 int index) { 400 int leftKeysLength = 0, rightKeysLength = 0; 401 for (int i = 0; i < lefTdCount; i++) { 402 leftKeysLength += keys[index]; 403 index += keys[index]; 404 } 405 int lengthOfLeftAndRight[] = new int[2]; 406 lengthOfLeftAndRight[0] = leftKeysLength + lefTdCount; 407 for (int i = 0; i < rightTdCount; i++) { 408 rightKeysLength += keys[index]; 409 index += keys[index]; 410 } 411 lengthOfLeftAndRight[1] = rightKeysLength + rightTdCount; 412 return lengthOfLeftAndRight; 413 } 414 415 420 421 public Object getKey() throws DException { 422 ArrayList list = new ArrayList(); 423 Object [] leftKeys = (Object []) leftIterator.getKey(); 424 this.leftCount = leftKeys.length; 425 list.addAll(Arrays.asList(leftKeys)); 426 list.addAll(Arrays.asList( (Object []) rightIterator.getKey())); 427 return list.toArray(); 428 } 429 430 442 public void move(Object keys) throws DException { 443 if (leftKeyCount != 0 || rightKeyCount != 0) { 444 moveAcctoGroupKey( (Object []) keys); 445 return; 446 } 447 Object [] leftKeys = new Object [leftCount]; 448 Object [] rightKeys = new Object [ ( (Object []) keys).length - leftCount]; 449 System.arraycopy(keys, 0, leftKeys, 0, leftCount); 450 System.arraycopy(keys, leftCount, rightKeys, 0, rightKeys.length); 451 leftIterator.move(leftKeys); 452 getAndSetConditionValues(); 453 rightIterator.move(rightKeys); 454 state = VALIDSTATE; 455 } 456 457 468 private void moveAcctoGroupKey(Object [] keys) throws DException { 469 if (leftKeyCount == 0) { 470 leftIterator.first(); 471 } else { 472 Object [] leftKeys = new Object [leftKeyCount]; 473 System.arraycopy(keys, 0, leftKeys, 0, leftKeyCount); 474 leftIterator.move(leftKeys); 475 } 476 getAndSetConditionValues(); 477 if (rightKeyCount == 0) { 478 rightIterator.first(); 479 } else { 480 int rightLength = keys.length - leftKeyCount; 481 Object [] rightKeys = new Object [rightLength]; 482 System.arraycopy(keys, leftKeyCount, rightKeys, 0, rightLength); 483 rightIterator.move(rightKeys); 484 } 485 state = VALIDSTATE; 486 } 487 488 495 504 public Object getColumnValues(_Reference[] leftColumnReferences) throws DException { 505 int len = leftColumnReferences.length; 506 Object [] values = new Object [len]; 507 for (int i = 0; i < len; i++) { 508 values[i] = getColumnValues(leftColumnReferences[i]); 509 } 510 return values; 511 } 512 513 521 public Object getColumnValues(int[] parm1) throws DException { 522 return getColumnValues(); 523 } 524 525 534 public Object getColumnValues() throws DException { 535 ArrayList aList = new ArrayList(); 536 Object obj = leftIterator.getColumnValues(); 537 if (obj != null) { 538 aList.addAll(Arrays.asList( (Object []) obj)); 539 } 540 obj = rightIterator.getColumnValues(); 541 if (obj != null) { 542 aList.addAll(Arrays.asList( (Object []) obj)); 543 } 544 return aList.toArray(); 545 } 546 547 558 public Object getColumnValues(_Reference references) throws DException { 559 TableDetails tDetails = ( (ColumnDetails) references).getTable(); 560 int index = searchInMapping(tDetails); 561 return index != -1 ? index == SimpleConstants.LEFT ? leftIterator.getColumnValues(references) 562 : rightIterator.getColumnValues(references) 563 : GeneralPurposeStaticClass.getColumnValuesFromBoth(leftIterator, rightIterator, references); 564 } 565 566 574 public FieldBase field(_Reference references) throws DException { 575 TableDetails tDetails = ( (ColumnDetails) references).getTable(); 576 int index = searchInMapping(tDetails); 577 return index != -1 ? index == SimpleConstants.LEFT ? leftIterator.field(references) 578 : rightIterator.field(references) 579 : GeneralPurposeStaticClass.getFieldValuesFromBoth(leftIterator, rightIterator, references); 580 } 581 582 590 public FieldBase[] fields(_Reference[] leftColumnReferences) throws DException { 591 int len = leftColumnReferences.length; 592 FieldBase[] values = new FieldBase[len]; 593 for (int i = 0; i < len; i++) { 594 values[i] = field(leftColumnReferences[i]); 595 } 596 return values; 597 } 598 599 606 private int searchInMapping(TableDetails tDetails) throws DException { 607 for (int i = 0; i < tableDetailsMapping.length; i++) { 608 if (tableDetailsMapping[i][0] == tDetails) { 609 return ( (Integer ) tableDetailsMapping[i][1]).intValue(); 610 } 611 } 612 return -1; 613 } 614 615 618 619 630 public void getAndSetConditionValues() throws DException { 631 Object [] values = (Object []) leftIterator.getColumnValues(leftColumnReferences); 632 rightIterator.setConditionVariableValue(leftColumnReferences, values, 1); 633 } 634 635 642 public void setKeyCount(Object [][] tableAndKeyCount) throws DException { 643 int[] counts = GeneralPurposeStaticClass.getLeftandRightKeyCount( 644 leftIterator, rightIterator, tableAndKeyCount, tableDetailsMapping); 645 leftKeyCount = counts[0]; 646 rightKeyCount = counts[1]; 647 } 648 649 657 public TableDetails[] getTableDetails() throws DException { 658 TableDetails[] tableDetails1 = leftIterator.getTableDetails(); 659 TableDetails[] tableDetails2 = rightIterator.getTableDetails(); 660 int len = tableDetails1.length + tableDetails2.length; 661 tableDetailsMapping = new Object [len][2]; 662 int i = 0; 663 Integer flag = new Integer (SimpleConstants.LEFT); 664 for (int j = 0; j < tableDetails1.length; j++) { 665 tableDetailsMapping[i][0] = tableDetails1[j]; 666 tableDetailsMapping[i++][1] = flag; 667 } 668 flag = new Integer (SimpleConstants.RIGHT); 669 for (int j = 0; j < tableDetails2.length; j++) { 670 tableDetailsMapping[i][0] = tableDetails2[j]; 671 tableDetailsMapping[i++][1] = flag; 672 } 673 TableDetails[] resultantTableDetails = new TableDetails[len]; 674 System.arraycopy(tableDetails1, 0, resultantTableDetails, 0, tableDetails1.length); 675 System.arraycopy(tableDetails2, 0, resultantTableDetails, tableDetails1.length, tableDetails2.length); 676 return resultantTableDetails; 677 } 678 679 687 public _KeyColumnInformation[] getKeyColumnInformations() throws DException { 688 _KeyColumnInformation[] leftKeyColumnInformation = leftIterator.getKeyColumnInformations(); 689 _KeyColumnInformation[] rightKeyColumnInformation = rightIterator.getKeyColumnInformations(); 690 this.leftCount = leftKeyColumnInformation.length; 691 int len = leftKeyColumnInformation.length + rightKeyColumnInformation.length; 692 _KeyColumnInformation[] resultantKeyColumnInformation = new _KeyColumnInformation[len]; 693 System.arraycopy(leftKeyColumnInformation, 0, resultantKeyColumnInformation, 0, leftKeyColumnInformation.length); 694 System.arraycopy(rightKeyColumnInformation, 0, resultantKeyColumnInformation, leftKeyColumnInformation.length, rightKeyColumnInformation.length); 695 return resultantKeyColumnInformation; 696 } 697 698 707 public _Iterator getBaseIterator(ColumnDetails column) throws DException { 708 int len = tableDetailsMapping.length; 709 for (int i = 0; i < len; i++) { 710 if (tableDetailsMapping[i][0] == column.getTableDetails()) { 711 return (tableDetailsMapping[i][1].hashCode() == SimpleConstants.LEFT) ? leftIterator.getBaseIterator(column) : rightIterator.getBaseIterator(column); 712 } 713 } 714 _Iterator left = leftIterator.getBaseIterator(column); 715 return left != null ? left : rightIterator.getBaseIterator(column); 716 } 717 718 723 public _ExecutionPlan getExecutionPlan() throws DException { 724 _ExecutionPlan plan = leftIterator.getExecutionPlan(); 725 _ExecutionPlan plan1 = rightIterator.getExecutionPlan(); 726 _ExecutionPlan cplans[] = new _ExecutionPlan[] {plan, plan1}; 727 return new ExecutionPlan("JoinIterator", cplans, null, null, null); 728 } 729 730 735 public ExecutionPlanForBrowser getExecutionPlanForBrowser() throws DException { 736 int length = 2; 737 ExecutionPlanForBrowser cplans[] = new ExecutionPlanForBrowser[length]; 738 cplans[0] = leftIterator.getExecutionPlanForBrowser(); 739 cplans[1] = rightIterator.getExecutionPlanForBrowser(); 740 String refer = leftColumnReferences == null ? "" : "" + Arrays.asList(leftColumnReferences); 741 refer = " Outer Reference " + refer; 742 return new ExecutionPlanForBrowser("Nested Join/Inner Join" + refer, "Join Iterator", cplans, null, null, null); 743 } 744 745 750 751 public Object [] getUniqueColumnReference() throws DException { 752 return GeneralPurposeStaticClass.getUniqueColumnReference(leftIterator, rightIterator); 753 } 754 755 public boolean seek(Object indexKey) throws DException { 756 return GeneralPurposeStaticClass.seek(indexKey, leftIterator, rightIterator); 757 } 758 759 764 765 public _Order getDefaultOrder() throws DException { 766 return GeneralPurposeStaticClass.getJoinOrdered(leftIterator.getDefaultOrder(), rightIterator.getDefaultOrder()); 767 } 768 769 770 public String toString() { 771 return "JoinIterator[" + leftIterator + "]\n\n\n[" + rightIterator + "]"; 772 } 773 } 774 | Popular Tags |