Revision 511 trunk/org.gvsig.postgresql/org.gvsig.postgresql.provider/src/main/java/org/gvsig/postgresql/dal/operations/PostgreSQLFetchFeatureTypeOperation.java

View differences:

PostgreSQLFetchFeatureTypeOperation.java
11 11
import java.util.Map;
12 12
import org.apache.commons.lang3.StringUtils;
13 13
import org.cresques.cts.IProjection;
14
import org.gvsig.expressionevaluator.ExpressionBuilder;
14 15
import org.gvsig.fmap.dal.DataTypes;
15 16
import org.gvsig.fmap.dal.exception.DataException;
16 17
import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;
......
74 75

  
75 76
        return super.getDataTypeFromMetadata(rsMetadata, colIndex);
76 77
    }
78
    
79
    @Override
77 80
    protected String getSQLToRetrievePrimaryKeysFromInformationSchema(
78 81
            String catalog,
79 82
            String schema,
80 83
            String table
81 84
        ) throws SQLException {
82 85
        PostgreSQLBuilder sqlbuilder = (PostgreSQLBuilder) this.createSQLBuilder();
83

  
86
        ExpressionBuilder expbuilder = sqlbuilder.expression();
87
        
84 88
        String column_COLUMN_NAME = "column_name";
85 89
        String column_CONSTRAINT_TYPE = "constraint_type";
86 90
        
......
99 103
                + "c.constraint_name = t_cons.constraint_name "
100 104
        );
101 105
        sqlbuilder.select().where().set(
102
                sqlbuilder.like(
103
                        sqlbuilder.custom("c.TABLE_NAME"), 
104
                        sqlbuilder.constant(table)
106
                expbuilder.like(
107
                        expbuilder.custom("c.TABLE_NAME"), 
108
                        expbuilder.constant(table)
105 109
                )
106 110
        );
107 111
        if (schema != null) {
108 112
            sqlbuilder.select().where().and(
109
                    sqlbuilder.like(
110
                            sqlbuilder.custom("c.TABLE_SCHEMA"),
111
                            sqlbuilder.constant(schema)
113
                    expbuilder.like(
114
                            expbuilder.custom("c.TABLE_SCHEMA"),
115
                            expbuilder.constant(schema)
112 116
                    )
113 117
            );
114 118
        }
115 119
        if (catalog != null) {
116 120
            sqlbuilder.select().where().and(
117
                    sqlbuilder.like(
118
                            sqlbuilder.custom("c.CONSTRAINT_CATALOG"),
119
                            sqlbuilder.constant(catalog)
121
                    expbuilder.like(
122
                            expbuilder.custom("c.CONSTRAINT_CATALOG"),
123
                            expbuilder.constant(catalog)
120 124
                    )
121 125
            );
122 126
        }
123 127
        sqlbuilder.select().where().and(
124
                sqlbuilder.eq(
125
                        sqlbuilder.column(column_CONSTRAINT_TYPE),
126
                        sqlbuilder.constant("PRIMARY KEY")
128
                expbuilder.eq(
129
                        expbuilder.column(column_CONSTRAINT_TYPE),
130
                        expbuilder.constant("PRIMARY KEY")
127 131
                )
128 132
        );
129 133
        return sqlbuilder.toString();
......
140 144
        }
141 145
        try {
142 146
            JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();
147
            ExpressionBuilder expbuilder = sqlbuilder.expression();
148
            
143 149
            sqlbuilder.select().column().name("f_table_catalog");
144 150
            sqlbuilder.select().column().name("f_table_schema");
145 151
            sqlbuilder.select().column().name("f_table_name");
......
148 154
            sqlbuilder.select().column().name("srid");
149 155
            sqlbuilder.select().column().name("type");
150 156
            sqlbuilder.select().where().set(
151
                    sqlbuilder.eq(
152
                            sqlbuilder.column("f_table_name"),
153
                            sqlbuilder.constant(this.getTable().getTable())
157
                    expbuilder.eq(
158
                            expbuilder.column("f_table_name"),
159
                            expbuilder.constant(this.getTable().getTable())
154 160
                    )
155 161
            );                
156 162
            sqlbuilder.select().where().and(
157
                    sqlbuilder.eq(
158
                            sqlbuilder.column("f_geometry_column"),
159
                            sqlbuilder.constant(attr.getName())
163
                    expbuilder.eq(
164
                            expbuilder.column("f_geometry_column"),
165
                            expbuilder.constant(attr.getName())
160 166
                    )
161 167
            );         
162 168
            sqlbuilder.select().from().table().name("geometry_columns");

Also available in: Unified diff