Revision 46543 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/JDBCHelperBase.java

View differences:

JDBCHelperBase.java
1074 1074
        });
1075 1075
        
1076 1076
        for (ExpressionBuilder.Variable variable : variables) {
1077
//            boolean found = false;
1078
//            for (ExpressionBuilder.Value v : variablesToExclude) {
1079
//                if(v == variable){
1080
//                    found = true;
1081
//                    break;
1082
//                }
1083
//            }
1084
//            if(found){
1085
//                continue;
1086
//            }
1087 1077
            ExpressionBuilder.Variable variable_replacement = null;
1088

  
1089 1078
            
1090
            if(variable instanceof SQLBuilder.Column) {
1091
                Column column = (SQLBuilder.Column) variable;
1092
                if (column.table() != null && column.table().has_name()) {
1093
                    if(!fromTable.has_schema()){
1079
            Pair<SQLBuilder.TableNameBuilder, FeatureType> tableNameAndFeatureType = getTableAndFeatureType(outerTables, variable.name());
1080
            if (tableNameAndFeatureType != null) {
1081
                SQLBuilder.TableNameBuilder variableTable = tableNameAndFeatureType.getLeft();
1094 1082

  
1095
                         continue;
1083
                if (variable instanceof SQLBuilder.Column) {
1084
                    Column column = (SQLBuilder.Column) variable;
1085
                    if (column.table() != null && column.table().has_name()) {
1086
                        if (column.table().has_schema()) {
1087
                            //La columna tiene tabla y esquema => No hacemos nada
1088
                        } else {
1089
                            if(column.table().getName().equals(variableTable.getName())){
1090
                                SQLBuilder.TableNameBuilder t = sqlbuilder.createTableNameBuilder()
1091
                                        .name(column.table().getName())
1092
                                        .schema(variableTable.getSchema());
1093
                                variable_replacement = sqlbuilder.column_from(
1094
                                        t,
1095
                                        variable
1096
                                );
1097
                            } else {
1098
                                if(fromTable.has_schema()){
1099
                                    SQLBuilder.TableNameBuilder t = sqlbuilder.createTableNameBuilder()
1100
                                            .name(column.table().getName())
1101
                                            .schema(fromTable.getSchema()); //Mismo esquema que en el FROM
1102
                                    variable_replacement = sqlbuilder.column_from(
1103
                                            t,
1104
                                            variable
1105
                                    );
1106
                                } else {
1107
                                    // No tiene esquema ni podemos averiguarlo => No hacemos nada
1108
                                }
1109
                            }
1110
                        }
1111
                    } else {
1112
                        column = sqlbuilder.column_from(tableNameAndFeatureType.getLeft(), variable);
1113
                        column.setProperty(SQLBuilder.PROP_FEATURE_TYPE, tableNameAndFeatureType.getRight());
1114
                        variable_replacement = column;
1096 1115
                    }
1097
                    SQLBuilder.TableNameBuilder t = sqlbuilder.table_name()
1098
                            .name(column.table().getName())
1099
                            .schema(fromTable.getSchema()); //Mismo esquema que en el FROM
1100
                    variable_replacement = sqlbuilder.column_from(
1101
                            t,
1102
                            variable
1103
                    );
1104
                }
1105
            }
1106
            
1107
            if (variable_replacement == null) {
1108
                Pair<SQLBuilder.TableNameBuilder, FeatureType> tableNameAndFeatureType = getTableAndFeatureType(outerTables, variable.name());
1109
                if (tableNameAndFeatureType != null) {
1116
                } else {
1110 1117
                    Column column = sqlbuilder.column_from(tableNameAndFeatureType.getLeft(), variable);
1111 1118
                    column.setProperty(SQLBuilder.PROP_FEATURE_TYPE, tableNameAndFeatureType.getRight());
1112 1119
                    variable_replacement = column;
1113
                } else {
1114
                    if (variable instanceof SQLBuilder.Column) {
1115
                        Column column = (SQLBuilder.Column) variable;
1116
                        if (column.table() == null || !column.table().has_name()) {
1117
                            variable_replacement = sqlbuilder.column_from(
1118
                                    fromTable,
1119
                                    variable
1120
                            );
1121
                        } else if (!column.table().has_schema()) {
1122
                            SQLBuilder.TableNameBuilder t = sqlbuilder.table_name()
1120
                }
1121

  
1122
            } else {
1123
                if (variable instanceof SQLBuilder.Column) {
1124
                    Column column = (SQLBuilder.Column) variable;
1125
                    if (column.table() == null || !column.table().has_name()) {
1126
                        variable_replacement = sqlbuilder.column_from(
1127
                                fromTable,
1128
                                variable
1129
                        );
1130
                    } else if (!column.table().has_schema()) {
1131
                        if(fromTable.has_schema()){
1132
                            SQLBuilder.TableNameBuilder t = sqlbuilder.createTableNameBuilder()
1123 1133
                                    .name(column.table().getName())
1124 1134
                                    .schema(fromTable.getSchema()); //Mismo esquema que en el FROM
1125 1135
                            variable_replacement = sqlbuilder.column_from(
1126 1136
                                    t,
1127 1137
                                    variable
1128 1138
                            );
1139
                        } else {
1140
                            // No tiene esquema ni podemos averiguarlo => No hacemos nada
1129 1141
                        }
1130
                    } else {
1131
                        variable_replacement = sqlbuilder.column_from(
1132
                                fromTable,
1133
                                variable
1134
                        );
1135 1142
                    }
1143
                } else {
1144
                    variable_replacement = sqlbuilder.column_from(
1145
                            fromTable,
1146
                            variable
1147
                    );
1136 1148
                }
1137 1149
            }
1138 1150
            if(variable_replacement != null){

Also available in: Unified diff