Revision 47784 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/expressionevaluator/impl/function/dataaccess/SelectFunction.java

View differences:

SelectFunction.java
55 55
import static org.gvsig.fmap.dal.SQLBuilder.PROP_TABLE;
56 56
import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;
57 57
import org.gvsig.fmap.dal.feature.Feature;
58
import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
58 59
import org.gvsig.fmap.dal.feature.FeatureQuery;
59 60
import org.gvsig.fmap.dal.feature.FeatureQueryOrder;
60 61
import org.gvsig.fmap.dal.feature.FeatureStore;
......
345 346
            if (sqlBuilder == null) {
346 347
                return super.toValue(builder, args);
347 348
            }
348
            Function<String, FeatureType> featureTypeSupplier = (Function<String, FeatureType>) builder.getProperty(PROP_FEATURETYPESUPPLIER);
349
            if (featureTypeSupplier == null) {
350
                featureTypeSupplier = (String tableName) -> {
351
                    DataManager dataManager = DALLocator.getDataManager();
352
                    FeatureType featureType = dataManager.getStoresRepository().getFeatureType(tableName);
353
                    return featureType;
354
                };
355
            }
356
            FeatureType featureType = null;
349
//            Function<String, FeatureType> featureTypeSupplier = (Function<String, FeatureType>) builder.getProperty(PROP_FEATURETYPESUPPLIER);
350
//            if (featureTypeSupplier == null) {
351
//                featureTypeSupplier = (String tableName) -> {
352
//                    DataManager dataManager = DALLocator.getDataManager();
353
//                    FeatureType featureType = dataManager.getStoresRepository().getFeatureType(tableName);
354
//                    return featureType;
355
//                };
356
//            }
357 357
            SQLBuilder.SelectBuilder select = sqlBuilder.createSelectBuilder();
358 358
            String builderTableName = (String) builder.getProperty(SQLBuilder.PROP_TABLENAME);
359 359

  
......
412 412

  
413 413
            SQLBuilder.TableNameBuilder table = select.from().table();
414 414
            String tableName = table.getName();
415
            FeatureType featureType;
416
            if (StringUtils.equalsIgnoreCase(builderTableName, tableName)) {
417
                featureType = (FeatureType) builder.getProperty(SQLBuilder.PROP_FEATURE_TYPE);
418
            } else {
419
                DataManager dataManager = DALLocator.getDataManager();
420
                featureType = dataManager.getStoresRepository().getFeatureType(tableName);
421
            }
422
            table.setFeatureType(featureType);
423
            
415 424
            if (columns == null || columns.parameters().isEmpty()){
416 425
                if( intovar==null ) {
417 426
                    select.column().all();
......
424 433
                        select.column().value(builder.constant(null));
425 434
                    } else if (column instanceof Code.Identifier) {
426 435
                        String columnName = ((Code.Identifier) column).name();
427
                        if(featureType == null) {
428
                            if(StringUtils.equalsIgnoreCase(builderTableName, tableName)){
429
                                featureType = (FeatureType) builder.getProperty(SQLBuilder.PROP_FEATURE_TYPE);
430
                            } else {
431
                                featureType = featureTypeSupplier.apply(tableName);
432
                            }
433
                        }
434
                        if(featureType == null){
435
                            select.column().name(select.from().table(),columnName);
436
                        } else if(featureType.get(columnName) != null) {
437
                            select.column().name(select.from().table(),columnName);
438
                        } else {
439
                            select.column().name(columnName).table(null);
440
                        }
436
//                        if(featureType == null) {
437
//                            if(StringUtils.equalsIgnoreCase(builderTableName, tableName)){
438
//                                featureType = (FeatureType) builder.getProperty(SQLBuilder.PROP_FEATURE_TYPE);
439
//                            } else {
440
//                                featureType = featureTypeSupplier.apply(tableName);
441
//                            }
442
//                        }
443
//                        if(featureType == null){
444
                            select.column().name(table,columnName);
445
//                        } else if(featureType.get(columnName) != null) {
446
//                            select.column().name(table,columnName);
447
//                        } else {
448
//                            select.column().name(columnName).table(null);
449
//                        }
441 450
                    } else {
442
                        select.column().value(column.toValue(builder));
451
                        select.column().value(setTableName(table, column.toValue(builder)));
443 452
                    }
444 453
                }
445 454
            }
446 455

  
447 456
            if (where != null) {
448
                ExpressionBuilder.Value value = where.toValue(builder);
457
                ExpressionBuilder.Value value = setTableName(table, where.toValue(builder));
449 458
                select.where().value(value);
450 459
                sqlBuilder.setProperties(value, null, SQLBuilder.PROP_ADD_TABLE_NAME_TO_COLUMNS, true);
451 460
            }
......
461 470
                for (int n = 0; n < order.parameters().size(); n++) {
462 471
                    Code member = order.parameters().get(n);
463 472
                    Code.Constant mode = (Code.Constant) order_mode.parameters().get(n);
464
                    select.order_by().value(member.toValue(builder)).ascending((boolean) mode.value());
473
                    select.order_by()
474
                            .value(setTableName(table,member.toValue(builder)))
475
                            .ascending((boolean) mode.value());
465 476
                }
466 477
            }
467
            if (featureType == null) {
468
                if (StringUtils.equalsIgnoreCase(builderTableName, tableName)) {
469
                    featureType = (FeatureType) builder.getProperty(SQLBuilder.PROP_FEATURE_TYPE);
470
                } else {
471
                    featureType = featureTypeSupplier.apply(tableName);
472
                }
473
            }
478
//            if (featureType == null) {
479
//                if (StringUtils.equalsIgnoreCase(builderTableName, tableName)) {
480
//                    featureType = (FeatureType) builder.getProperty(SQLBuilder.PROP_FEATURE_TYPE);
481
//                } else {
482
//                    featureType = featureTypeSupplier.apply(tableName);
483
//                }
484
//            }
474 485

  
475 486
            sqlBuilder.setProperties(
476 487
                    select,
......
502 513
        
503 514
        return values.toString();
504 515
    }
505
    
516

  
517
    private ExpressionBuilder.Value setTableName(SQLBuilder.TableNameBuilder table, ExpressionBuilder.Value value) {
518
        value.accept(new ExpressionBuilder.Visitor() {
519
            @Override
520
            public void visit(ExpressionBuilder.Visitable value) {
521
                if( value instanceof SQLBuilder.Column) {
522
                    SQLBuilder.Column c = (SQLBuilder.Column) value;
523
                    SQLBuilder.TableNameBuilder t = c.table();
524
                    if( t==null ) {
525
                        c.table(table);
526
                        return;
527
                    }
528
                    if( t.equals(table) ) {
529
                        t.setFeatureType(table.featureType());
530
                    }
531
                }
532
            }
533
        }, null);
534
        return value;
535
    }
506 536
}

Also available in: Unified diff