MentaBean

Rev

Rev 180 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
80 soliveira 1
package org.mentabean.jdbc;
2
 
3
import java.sql.Connection;
4
import java.sql.PreparedStatement;
5
import java.sql.ResultSet;
6
 
7
import org.mentabean.BeanConfig;
8
import org.mentabean.BeanException;
9
import org.mentabean.BeanManager;
10
import org.mentabean.DBField;
149 erico 11
import org.mentabean.DBType;
12
import org.mentabean.type.ByteArrayType;
163 erico 13
import org.mentabean.type.LongType;
126 soliveira 14
import org.mentabean.util.Limit;
125 soliveira 15
import org.mentabean.util.OrderBy;
80 soliveira 16
 
17
/**
18
 *
19
 * Now in PostgreSQL is 'current_timestamp'.
20
 *
21
 * PostgreSQL only supports sequences for primary keys.
22
 *
23
 * @author erico_kl
24
 *
25
 */
26
public class PostgreSQLBeanSession extends AnsiSQLBeanSession {
27
 
28
        public PostgreSQLBeanSession(BeanManager beanManager, Connection conn) {
29
 
30
                super(beanManager, conn);
31
        }
32
 
33
        @Override
34
        protected String getCurrentTimestampCommand() {
35
 
36
                return "current_timestamp";
37
        }
38
 
39
        /**
40
         * PostgreSQL will sort first then apply limit
41
         */
42
        @Override
126 soliveira 43
        protected StringBuilder handleLimit(final StringBuilder sb, final OrderBy orderBy, final Limit limit) {
80 soliveira 44
 
126 soliveira 45
                if (limit == null || limit.intValue() <= 0) {
80 soliveira 46
                        return sb;
47
                }
48
 
49
                final StringBuilder sbLimit = new StringBuilder(sb.length() + 32);
50
 
51
                sbLimit.append(sb.toString()).append(" LIMIT ").append(limit);
52
 
53
                return sbLimit;
54
        }
55
 
56
        @Override
57
        public void insert(final Object bean) {
58
 
59
                // find sequence field...
60
                final BeanConfig bc = beanManager.getBeanConfig(bean.getClass());
61
 
62
                if (bc == null) {
63
 
64
                        throw new BeanException("Cannot find bean config: " + bean.getClass());
65
                }
66
 
67
                final DBField seqField = bc.getSequenceField();
68
 
69
                if (seqField == null) {
70
 
202 erico 71
                        //find autoincrement field
72
 
80 soliveira 73
                        super.insert(bean);
74
 
202 erico 75
                        final DBField autoIncrement = bc.getAutoIncrementField();
76
 
77
                        if (autoIncrement == null) {
78
 
79
                                dispatchAfterInsert(bean);
80
 
81
                                return;
82
                        }
180 erico 83
 
202 erico 84
                        PreparedStatement stmt = null;
85
 
86
                        ResultSet rset = null;
87
 
88
                        StringBuilder sb = new StringBuilder("select lastval();");
89
 
90
                        try {
91
 
92
                                stmt = conn.prepareStatement(sb.toString());
93
 
94
                                rset = stmt.executeQuery();
95
 
96
                                if (rset.next()) {
97
 
98
                                        final long id = rset.getLong(1);
99
 
100
                                        try {
101
 
102
                                                injectValue(bean, autoIncrement.getName(), id, Integer.class);
103
 
104
                                        } catch(Exception e) {
105
 
106
                                                // try long as well:
107
                                                injectValue(bean, autoIncrement.getName(), id, Long.class);
108
                                        }
109
 
110
                                        dispatchAfterInsert(bean);
111
 
112
                                        return;
113
                                }
114
 
115
 
116
                        } catch (Exception e) {
117
 
118
                                throw new BeanException(e);
119
 
120
                        } finally {
121
 
122
                                close(stmt, rset);
123
                        }
80 soliveira 124
                }
125
 
126
                String seqName = bc.getSequenceName();
127
 
128
                if (seqName == null) {
129
 
130
                        seqName = bc.getTableName() + "_seq";
131
 
132
                }
133
 
134
                PreparedStatement stmt = null;
135
                ResultSet rset = null;
136
 
137
                StringBuilder sb = new StringBuilder();
138
 
139
                //get the sequence's next value in pgsql way
140
                sb.append("select nextval ('").append(seqName).append("')");
141
 
142
                try {
143
 
144
                        stmt = conn.prepareStatement(sb.toString());
145
 
146
                        rset = stmt.executeQuery();
147
 
148
                        if (rset.next()) {
149
 
150
                                final long id = rset.getLong(1);
151
 
152
                                try {
153
 
154
                                        injectValue(bean, seqField.getName(), id, Integer.class);
155
 
156
                                } catch(Exception e) {
157
 
158
                                        // try long as well:
159
                                        injectValue(bean, seqField.getName(), id, Long.class);
160
                                }
149 erico 161
 
80 soliveira 162
                        }
163
 
164
                }catch (Exception e) {
165
 
149 erico 166
                        throw new BeanException("Error preparing statement to insert in PostgreSQL", e);
80 soliveira 167
 
168
                } finally {
169
                        //if (stmt != null) try { stmt.close(); } catch(Exception e) { }
170
                        close(stmt, rset);
171
                }
172
 
173
                super.insert(bean);
149 erico 174
 
175
                dispatchAfterInsert(bean);
176
 
80 soliveira 177
        }
136 erico 178
 
179
        protected boolean isVarcharUnlimitedSupported() {
180
 
181
                return true;
182
        }
149 erico 183
 
184
        @Override
185
        protected String getDatabaseType(DBType<?> dbType) {
186
 
163 erico 187
                if (dbType.getClass().equals(ByteArrayType.class))
149 erico 188
                        return "bytea";
163 erico 189
 
190
                if (dbType.getClass().equals(LongType.class))
191
                        return "bigint";
192
 
149 erico 193
                return super.getDatabaseType(dbType);
163 erico 194
 
149 erico 195
        }
80 soliveira 196
}