← Back to branch summary

~ubuntu-branches/ubuntu/wily/libhibernate3-java/wily-proposed

« back to all changes in this revision

Viewing changes to src/org/hibernate/id/SequenceGenerator.java

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2007-10-14 14:43:34 UTC
  • Revision ID: james.westby@ubuntu.com-20071014144334-eamc8i0q10gs1aro
Tags: upstream-3.2.5
Import upstream version 3.2.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/hibernate/id/SequenceGenerator.java
 
1
//$Id: SequenceGenerator.java 9686 2006-03-27 16:47:06Z steve.ebersole@jboss.com $
 
2
package org.hibernate.id;
 
3
 
 
4
import java.io.Serializable;
 
5
import java.sql.PreparedStatement;
 
6
import java.sql.ResultSet;
 
7
import java.sql.SQLException;
 
8
import java.util.Properties;
 
9
 
 
10
import org.apache.commons.logging.Log;
 
11
import org.apache.commons.logging.LogFactory;
 
12
import org.hibernate.HibernateException;
 
13
import org.hibernate.MappingException;
 
14
import org.hibernate.exception.JDBCExceptionHelper;
 
15
import org.hibernate.dialect.Dialect;
 
16
import org.hibernate.engine.SessionImplementor;
 
17
import org.hibernate.mapping.Table;
 
18
import org.hibernate.type.Type;
 
19
import org.hibernate.util.PropertiesHelper;
 
20
 
 
21
/**
 
22
 * <b>sequence</b><br>
 
23
 * <br>
 
24
 * Generates <tt>long</tt> values using an oracle-style sequence. A higher
 
25
 * performance algorithm is <tt>SequenceHiLoGenerator</tt>.<br>
 
26
 * <br>
 
27
 * Mapping parameters supported: sequence, parameters.
 
28
 *
 
29
 * @see SequenceHiLoGenerator
 
30
 * @see TableHiLoGenerator
 
31
 * @author Gavin King
 
32
 */
 
33
 
 
34
public class SequenceGenerator implements PersistentIdentifierGenerator, Configurable {
 
35
 
 
36
        /**
 
37
         * The sequence parameter
 
38
         */
 
39
        public static final String SEQUENCE = "sequence";
 
40
 
 
41
        /**
 
42
         * The parameters parameter, appended to the create sequence DDL.
 
43
         * For example (Oracle): <tt>INCREMENT BY 1 START WITH 1 MAXVALUE 100 NOCACHE</tt>.
 
44
         */
 
45
        public static final String PARAMETERS = "parameters";
 
46
 
 
47
        private String sequenceName;
 
48
        private String parameters;
 
49
        private Type identifierType;
 
50
        private String sql;
 
51
 
 
52
        private static final Log log = LogFactory.getLog(SequenceGenerator.class);
 
53
 
 
54
        public void configure(Type type, Properties params, Dialect dialect) throws MappingException {
 
55
                sequenceName = PropertiesHelper.getString(SEQUENCE, params, "hibernate_sequence");
 
56
                parameters = params.getProperty(PARAMETERS);
 
57
                String schemaName = params.getProperty(SCHEMA);
 
58
                String catalogName = params.getProperty(CATALOG);
 
59
 
 
60
                if (sequenceName.indexOf( '.' ) < 0) {
 
61
                        sequenceName = Table.qualify( catalogName, schemaName, sequenceName );
 
62
                }
 
63
 
 
64
                this.identifierType = type;
 
65
                sql = dialect.getSequenceNextValString(sequenceName);
 
66
        }
 
67
 
 
68
        public Serializable generate(SessionImplementor session, Object obj) 
 
69
        throws HibernateException {
 
70
                
 
71
                try {
 
72
 
 
73
                        PreparedStatement st = session.getBatcher().prepareSelectStatement(sql);
 
74
                        try {
 
75
                                ResultSet rs = st.executeQuery();
 
76
                                try {
 
77
                                        rs.next();
 
78
                                        Serializable result = IdentifierGeneratorFactory.get(
 
79
                                                        rs, identifierType
 
80
                                                );
 
81
                                        if ( log.isDebugEnabled() ) {
 
82
                                                log.debug("Sequence identifier generated: " + result);
 
83
                                        }
 
84
                                        return result;
 
85
                                }
 
86
                                finally {
 
87
                                        rs.close();
 
88
                                }
 
89
                        }
 
90
                        finally {
 
91
                                session.getBatcher().closeStatement(st);
 
92
                        }
 
93
                        
 
94
                }
 
95
                catch (SQLException sqle) {
 
96
                        throw JDBCExceptionHelper.convert(
 
97
                                        session.getFactory().getSQLExceptionConverter(),
 
98
                                        sqle,
 
99
                                        "could not get next sequence value",
 
100
                                        sql
 
101
                                );
 
102
                }
 
103
 
 
104
        }
 
105
 
 
106
        public String[] sqlCreateStrings(Dialect dialect) throws HibernateException {
 
107
                String[] ddl = dialect.getCreateSequenceStrings(sequenceName);
 
108
                if ( parameters != null ) {
 
109
                        ddl[ddl.length - 1] += ' ' + parameters;
 
110
                }
 
111
                return ddl;
 
112
        }
 
113
 
 
114
        public String[] sqlDropStrings(Dialect dialect) throws HibernateException {
 
115
                return dialect.getDropSequenceStrings(sequenceName);
 
116
        }
 
117
 
 
118
        public Object generatorKey() {
 
119
                return sequenceName;
 
120
        }
 
121
 
 
122
        public String getSequenceName() {
 
123
                return sequenceName;
 
124
        }
 
125
 
 
126
}