Revision 45989

View differences:

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/featureset/FastEditedFilteredIterator.java
30 30

  
31 31
public class FastEditedFilteredIterator extends FastEditedIterator {
32 32

  
33
	public FastEditedFilteredIterator(DefaultFeatureSet featureSet, long index)
33
	public FastEditedFilteredIterator(DefaultFeatureSet featureSet, long index, long elements)
34 34
			throws DataException {
35
		super(featureSet, index);
35
		super(featureSet, index, elements);
36 36
	}
37 37

  
38 38

  
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/featureset/FastEditedIterator.java
41 41

  
42 42
    private DefaultFeature myFeature;
43 43

  
44
    public FastEditedIterator(DefaultFeatureSet featureSet, long index)
44
    public FastEditedIterator(DefaultFeatureSet featureSet, long index, long elements)
45 45
        throws DataException {
46
        super(featureSet, index);
46
        super(featureSet, index, elements);
47 47
    }
48 48

  
49 49
    @Override
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/featureset/FastFilteredIterator.java
32 32

  
33 33
	DefaultFeature myFeature;
34 34

  
35
	FastFilteredIterator(DefaultFeatureSet featureSet, long index)
35
	FastFilteredIterator(DefaultFeatureSet featureSet, long index, long elements)
36 36
			throws DataException {
37 37
		super(featureSet);
38 38
		initializeFeature();
39

  
40
		this.iterator = featureSet.provider.fastIterator();
41
		if (index > 0) {
42
			this.skypto(index);
43
		}
39
                
40
                if(featureSet.provider.canFilter() && featureSet.provider.canIterateFromIndex()){
41
                    this.iterator = featureSet.provider.iterator(index, elements);
42
                } else {
43
                    this.iterator = featureSet.provider.iterator();
44
                    if (index > 0) {
45
                            this.skypto(index);
46
                    }
47
                }
44 48
	}
45 49

  
46 50
	protected DefaultFeature createFeature(FeatureProvider fData)
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/featureset/EditedFilteredIterator.java
31 31

  
32 32
public class EditedFilteredIterator extends EditedIterator {
33 33

  
34
	EditedFilteredIterator(DefaultFeatureSet fset, long index)
34
	EditedFilteredIterator(DefaultFeatureSet fset, long index, long elements)
35 35
			throws DataException {
36
		super(fset, index);
36
		super(fset, index, elements);
37 37
	}
38 38

  
39 39
        @Override
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/featureset/EditedIterator.java
23 23
 */
24 24
package org.gvsig.fmap.dal.feature.impl.featureset;
25 25

  
26
import java.util.HashSet;
26 27
import java.util.Iterator;
28
import java.util.Set;
27 29
import java.util.logging.Level;
28 30
import java.util.logging.Logger;
29 31
import org.gvsig.fmap.dal.exception.DataException;
......
35 37
import org.gvsig.fmap.dal.feature.impl.editing.memory.FeatureManager;
36 38
import org.gvsig.fmap.dal.feature.impl.featurereference.FeatureReferenceFactory;
37 39
import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
40
import org.gvsig.fmap.dal.feature.spi.FeatureSetProvider;
38 41
import org.gvsig.tools.exception.BaseException;
39 42
import org.gvsig.tools.util.ChainedIterator;
40 43

  
......
49 52

  
50 53
    private DefaultFeatureStore store;
51 54
    protected FeatureManager featureManager;
52

  
55
    private Set<FeatureReference> visitedReferences;
56
    
53 57
    public EditedIterator(DefaultFeatureSet featureSet) {
54 58
        super(featureSet);
55 59
        this.store = featureSet.store;
56 60
        this.featureManager = this.store.getFeatureManager();
61
        this.visitedReferences = new HashSet<>();
57 62
    }
58 63

  
59
    public EditedIterator(DefaultFeatureSet featureSet, long index)
64
    public EditedIterator(DefaultFeatureSet featureSet, long index, long elements)
60 65
        throws DataException {
61 66
        this(featureSet);
62 67

  
63 68
        Iterator<EditableFeature> insertedFeatures = this.featureManager.getInsertedFeatures();//Don't use getInserteds because referenceFeature will be missed
64 69
        Iterator<EditableFeature> updatedFeatures = this.featureManager.getUpdatedFeatures();
65
        final Iterator<FeatureProvider> providerIterator = featureSet.provider.iterator();
70
        final Iterator<FeatureProvider> providerIterator;
71
        FeatureSetProvider provider = featureSet.provider;
72
        boolean canDelegateInProvider = provider.canFilter() && provider.canIterateFromIndex() && !featureManager.hasDeleteds();
73
        if (canDelegateInProvider) {
74
            providerIterator = provider.iterator(index, elements);
75
        } else {
76
            providerIterator = provider.iterator();
77
        }
78

  
79

  
66 80
        Iterator<FeatureProvider> wrappedProviderIterator = new Iterator<FeatureProvider>() {
67 81
            @Override
68 82
            public boolean hasNext() {
......
80 94
                    return data;
81 95
                }
82 96
                if (modified != null) {
97
                    visitedReferences.add(ref);
83 98
                    return modified.getData();
84 99
                }
85 100
                return data;
......
90 105
                EditedIterator.super.remove();
91 106
            }
92 107
        };
93
        this.iterator = new ChainedIterator(wrappedProviderIterator, insertedFeatures);
94
        if (index > 0) {
95
            skypto(index);
108
        this.iterator = new ChainedIterator(wrappedProviderIterator, insertedFeatures, updatedFeatures);
109
        if (!canDelegateInProvider) {
110
            if (index > 0) {
111
                skypto(index);
112
            }
96 113
        }
97 114
    }
98 115
    
......
152 169
    @Override
153 170
    protected boolean skipFeature(FeatureProvider data) {
154 171
        try {
155
            if (getIterator().getCurrent() == 0) {
156
                if (this.featureManager.isDeleted(data)) {
157
                    return true;
158
                };
159
//                FeatureReference ref = FeatureReferenceFactory.createFromFeatureProvider(store, data);
160
//                if (this.featureManager.get(ref, store) != null) {
161
//                    return true;
162
//                };
172
            switch (getIterator().getCurrent()) {
173
                case 0:
174
                    if (this.featureManager.isDeleted(data)) {
175
                        return true;
176
                    }
177
                    break;
178
                case 2:
179
                    FeatureReference ref = FeatureReferenceFactory.createFromFeatureProvider(store, data);
180
                    if (visitedReferences.contains(ref)){
181
                        return true;
182
                    }
183
                    break;
163 184
            }
164 185
        } catch (Exception ex) {
165 186
            LOGGER.warn("Can't check if must skip feature.", ex);
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/featureset/FilteredIterator.java
47 47
		this.filter = featureSet.query.getFilter();
48 48
	}
49 49

  
50
	FilteredIterator(DefaultFeatureSet featureSet, long index)
50
	FilteredIterator(DefaultFeatureSet featureSet, long index, long elements)
51 51
			throws DataException {
52
		super(featureSet);
53
		this.iterator = featureSet.provider.iterator();
54
		if (index > 0) {
55
			this.skypto(index);
56
		}
57
		this.current = null;
58
		this.nextChecked = false;
59
		this.filter = featureSet.query.getFilter();
52
		this(featureSet);
53
                if(featureSet.provider.canFilter() && featureSet.provider.canIterateFromIndex()){
54
                    this.iterator = featureSet.provider.iterator(index, elements);
55
                } else {
56
                    this.iterator = featureSet.provider.iterator();
57
                    if (index > 0) {
58
                            this.skypto(index);
59
                    }
60
                }
60 61
	}
61 62

  
62 63
        @Override
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/featureset/DefaultFeatureSet.java
416 416
            break;
417 417

  
418 418
        case FILTERED:
419
            it = new FastFilteredIterator(this, index);
419
            it = new FastFilteredIterator(this, index, elements);
420 420
            break;
421 421

  
422 422
        case ORDERED:
423
            if (this.orderedData != null) {
424
                it = new FastOrderedIterator(this, index);
423
            if(this.provider.canOrder() && this.provider.canIterateFromIndex()){
424
                it = new FastDefaultIterator(this, index, elements);
425 425
            } else {
426
                it = new FastOrderedIterator(this, new FastDefaultIterator(this, 0, elements), index);
426
                if (this.orderedData != null) {
427
                    it = new FastOrderedIterator(this, index);
428
                } else {
429
                    it = new FastOrderedIterator(this, new FastDefaultIterator(this, 0, -1), index);
430
                }
427 431
            }
428 432
            break;
429 433
            
430 434
        case ORDERED_FILTERED:
431
            if (this.orderedData != null) {
432
                it = new FastOrderedIterator(this, index);
435
            if(this.provider.canOrder() && this.provider.canFilter() && this.provider.canIterateFromIndex()){
436
                it = new FastFilteredIterator(this, index, elements);
433 437
            } else {
434
                it = new FastOrderedIterator(this, new FastFilteredIterator(
435
                    this, 0), index);
438
                if (this.orderedData != null) {
439
                    it = new FastOrderedIterator(this, index);
440
                } else {
441
                    it = new FastOrderedIterator(this, new FastFilteredIterator(
442
                        this, 0, -1), index);
443
                }
436 444
            }
445

  
437 446
            break;
438 447

  
439 448
        case EDITED:
440
            it = new FastEditedIterator(this, index);
449
            it = new FastEditedIterator(this, index, elements);
441 450
            break;
442 451

  
443 452
        case EDITED_FILTERED:
444
            it = new FastEditedFilteredIterator(this, index);
453
            it = new FastEditedFilteredIterator(this, index, elements);
445 454
            break;
446 455

  
447 456
        case ORDERD_EDITED:
448
            if (this.orderedData != null) {
449
                it = new FastOrderedIterator(this, index);
457
            if(this.provider.canOrder() && this.provider.canIterateFromIndex() && !this.store.getFeatureManager().hasDeleteds()){
458
                it = new FastEditedIterator(this, index, elements);
450 459
            } else {
451
                it = new FastOrderedIterator(this, new FastEditedIterator(
452
                    this, 0), index);
460
                if (this.orderedData != null) {
461
                    it = new FastOrderedIterator(this, index);
462
                } else {
463
                    it = new FastOrderedIterator(this, new FastEditedIterator(
464
                        this, 0, -1), index);
465
                }
453 466
            }
454 467
            break;
455 468

  
456 469
        case ORDERED_EDITED_FILTER:
457
            if (this.orderedData != null) {
458
                it = new FastOrderedIterator(this, index);
470
            if(this.provider.canOrder() && this.provider.canFilter() && this.provider.canIterateFromIndex() && !this.store.getFeatureManager().hasDeleteds()){
471
                it = new FastEditedFilteredIterator(this, index, elements);
459 472
            } else {
460
                it = new FastOrderedIterator(this,
461
                    new FastEditedFilteredIterator(this, 0), index);
473
                if (this.orderedData != null) {
474
                    it = new FastOrderedIterator(this, index);
475
                } else {
476
                    it = new FastOrderedIterator(this,
477
                        new FastEditedFilteredIterator(this, 0, -1), index);
478
                }
462 479
            }
463 480
            break;
464 481
            
......
532 549
            break;
533 550

  
534 551
        case FILTERED:
535
            it = new FilteredIterator(this, index);
552
            it = new FilteredIterator(this, index, elements);
536 553
            break;
537 554

  
538 555
        case ORDERED:
539
            if (orderedData != null) {
540
                it = new OrderedIterator(this, index);
556
            if(this.provider.canOrder() && this.provider.canIterateFromIndex()){
557
                it = new DefaultIterator(this, index, elements);
558
            } else {
559
                if (orderedData != null) {
560
                    it = new OrderedIterator(this, index);
541 561

  
542
            } else {
543
                it = new OrderedIterator(this, new DefaultIterator(this, 0, elements),index);
562
                } else {
563
                    it = new OrderedIterator(this, new DefaultIterator(this, 0, elements),index);
564
                }
544 565
            }
545 566
            break;
546 567

  
547 568
        case ORDERED_FILTERED:
548
            it = new OrderedIterator(this, new FilteredIterator(this, 0),
549
                index);
569
            if(this.provider.canOrder() && this.provider.canFilter() && this.provider.canIterateFromIndex()){
570
                it = new FilteredIterator(this, index, elements);
571
            } else {
572
                if (orderedData != null) {
573
                    it = new OrderedIterator(this, index);
574
                } else {
575
                    it = new OrderedIterator(this, new FilteredIterator(this, 0, -1),index);
576
                }
577
            }
550 578
            break;
551 579

  
552 580
        case EDITED:
553
            it = new EditedIterator(this, index);
581
            it = new EditedIterator(this, index, elements);
554 582
            break;
555 583

  
556 584
        case EDITED_FILTERED:
557
            it = new EditedFilteredIterator(this, index);
585
            it = new EditedFilteredIterator(this, index, elements);
558 586
            break;
559 587

  
560 588
        case ORDERD_EDITED:
561
            it = new OrderedIterator(this, new EditedIterator(this, 0), index);
589
            if(this.provider.canOrder() && this.provider.canIterateFromIndex() && !this.store.getFeatureManager().hasDeleteds()){
590
                it = new EditedIterator(this, index, elements);
591
            } else {
592
                if (orderedData != null) {
593
                    it = new OrderedIterator(this, index);
594
                } else {
595
                    it = new OrderedIterator(this,
596
                        new EditedIterator(this, 0, -1), index);
597
                }
598
            }
562 599
            break;
563 600

  
564 601
        case ORDERED_EDITED_FILTER:
565
            it = new OrderedIterator(this,
566
                new EditedFilteredIterator(this, 0), index);
602
            if(this.provider.canOrder() && this.providerCanFilter() && this.provider.canIterateFromIndex() && !this.store.getFeatureManager().hasDeleteds()){
603
                it = new EditedFilteredIterator(this, index, elements);
604
            } else {
605
                if (orderedData != null) {
606
                    it = new OrderedIterator(this, index);
607
                } else {
608
                    it = new OrderedIterator(this,
609
                        new EditedFilteredIterator(this, 0, -1), index);
610
                }
611
            }
567 612
            break;
568 613

  
569 614
        default:
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/editing/memory/FeatureManager.java
242 242
        return added.size() > 0 || modifiedFromOriginal.size() > 0 || deleted.size() > 0;
243 243
    }
244 244

  
245
    public boolean hasDeleteds() {
246
        return deleted.size() > 0;
247
    }
248

  
245 249
    public long getPendingChangesCount() {
246 250
        long count = 0;
247 251
        if( this.added!=null ) {
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.db/org.gvsig.fmap.dal.db.jdbc/src/main/java/org/gvsig/fmap/dal/store/jdbc2/spi/operations/ResultSetForSetProviderOperation.java
311 311
                    // Muy probablemente si no tiene pk sea una vista, asi que 
312 312
                    // pasaremos de ordenar y esperemos que la vista este ya ordenada.
313 313
                    select.disable_check_order_and_offset();
314
                } else {
315
                    for (String attrName : primaryKeys) {
316
                        // Se precisa indicar un orden para usar OFFSET.
317
                        //                    select.order_by().column(sqlbuilder.as_identifier(attrName)).ascending();
318
                        if(select.getOrderBy(attrName)==null){
319
                            select.order_by().column(attrName).ascending();
320
                        }
321
                    }
322

  
323 314
                }
324 315
            }
325 316
//        }
317
        for (String attrName : primaryKeys) {
318
            if(select.getOrderBy(attrName)==null){
319
                select.order_by().column(attrName).ascending();
320
            }
321
        }
326 322
        if (limit > 0) {
327 323
            select.limit(limit);
328 324
        } else {

Also available in: Unified diff