Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.openjpa.jdbc.kernel; import java.io.Serializable; import java.sql.Connection; import java.sql.ResultSet; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.Iterator; import java.util.Set; import org.apache.commons.lang.StringUtils; import org.apache.openjpa.conf.OpenJPAConfiguration; import org.apache.openjpa.jdbc.conf.JDBCConfiguration; import org.apache.openjpa.jdbc.meta.ClassMapping; import org.apache.openjpa.jdbc.sql.JoinSyntaxes; import org.apache.openjpa.kernel.FetchConfiguration; import org.apache.openjpa.kernel.FetchConfigurationImpl; import org.apache.openjpa.kernel.StoreContext; import org.apache.openjpa.lib.rop.EagerResultList; import org.apache.openjpa.lib.rop.ListResultObjectProvider; import org.apache.openjpa.lib.rop.ResultList; import org.apache.openjpa.lib.rop.ResultObjectProvider; import org.apache.openjpa.lib.rop.SimpleResultList; import org.apache.openjpa.lib.rop.SoftRandomAccessResultList; import org.apache.openjpa.lib.rop.WindowResultList; import org.apache.openjpa.lib.util.Localizer; import org.apache.openjpa.meta.FieldMetaData; import org.apache.openjpa.util.UserException; /** * JDBC extensions to OpenJPA's {@link FetchConfiguration}. * * @author Abe White * @nojavadoc */ @SuppressWarnings("serial") public class JDBCFetchConfigurationImpl extends FetchConfigurationImpl implements JDBCFetchConfiguration { private static final Localizer _loc = Localizer.forPackage(JDBCFetchConfigurationImpl.class); /** * Hint keys that correspond to a mutable bean-style setter in this receiver. * These keys are registered with both <code>openjpa.FetchPlan</code> and <code>openjpa.jdbc</code> as prefix. * <br> * A hint without a setter method is also recognized by this receiver. */ static { String[] prefixes = { "openjpa.FetchPlan", "openjpa.jdbc" }; Class<?> target = JDBCFetchConfiguration.class; populateHintSetter(target, "EagerFetchMode", int.class, prefixes); populateHintSetter(target, "FetchDirection", int.class, prefixes); populateHintSetter(target, "Isolation", int.class, prefixes); populateHintSetter(target, "setIsolation", "TransactionIsolation", int.class, "openjpa.jdbc"); populateHintSetter(target, "JoinSyntax", int.class, prefixes); populateHintSetter(target, "SubclassFetchMode", int.class, prefixes); populateHintSetter(target, "LRSSize", int.class, prefixes); populateHintSetter(target, "setLRSSize", "LRSSizeAlgorithm", int.class, prefixes); populateHintSetter(target, "ResultSetType", int.class, prefixes); } /** * Configurable JDBC state shared throughout a traversal chain. */ protected static class JDBCConfigurationState implements Serializable { public int eagerMode = 0; public int subclassMode = 0; public int type = 0; public int direction = 0; public int size = 0; public int syntax = 0; public Set<String> joins = null; public Set<String> fetchInnerJoins = null; public int isolationLevel = -1; public boolean ignoreDfgForFkSelect = false; } protected final JDBCConfigurationState _state; public JDBCFetchConfigurationImpl() { this(null, null); } protected JDBCFetchConfigurationImpl(ConfigurationState state, JDBCConfigurationState jstate) { super(state); _state = (jstate == null) ? new JDBCConfigurationState() : jstate; } protected FetchConfigurationImpl newInstance(ConfigurationState state) { JDBCConfigurationState jstate = (state == null) ? null : _state; return new JDBCFetchConfigurationImpl(state, jstate); } public void setContext(StoreContext ctx) { super.setContext(ctx); JDBCConfiguration conf = getJDBCConfiguration(); if (conf == null) return; setEagerFetchMode(conf.getEagerFetchModeConstant()); setSubclassFetchMode(conf.getSubclassFetchModeConstant()); setResultSetType(conf.getResultSetTypeConstant()); setFetchDirection(conf.getFetchDirectionConstant()); setLRSSize(conf.getLRSSizeConstant()); setJoinSyntax(conf.getDBDictionaryInstance().joinSyntax); } public void copy(FetchConfiguration fetch) { super.copy(fetch); JDBCFetchConfiguration jf = (JDBCFetchConfiguration) fetch; setEagerFetchMode(jf.getEagerFetchMode()); setSubclassFetchMode(jf.getSubclassFetchMode()); setResultSetType(jf.getResultSetType()); setFetchDirection(jf.getFetchDirection()); setLRSSize(jf.getLRSSize()); setJoinSyntax(jf.getJoinSyntax()); addJoins(jf.getJoins()); setIgnoreDfgForFkSelect(jf.getIgnoreDfgForFkSelect()); } @Override public boolean getIgnoreDfgForFkSelect() { return _state.ignoreDfgForFkSelect; } @Override public void setIgnoreDfgForFkSelect(boolean b) { _state.ignoreDfgForFkSelect = b; } public int getEagerFetchMode() { return _state.eagerMode; } public JDBCFetchConfiguration setEagerFetchMode(int mode) { if (mode != DEFAULT && mode != EagerFetchModes.EAGER_NONE && mode != EagerFetchModes.EAGER_JOIN && mode != EagerFetchModes.EAGER_PARALLEL) throw new IllegalArgumentException(_loc.get("bad-fetch-mode", Integer.valueOf(mode)).getMessage()); if (mode == DEFAULT) { JDBCConfiguration conf = getJDBCConfiguration(); if (conf != null) mode = conf.getEagerFetchModeConstant(); } if (mode != DEFAULT) _state.eagerMode = mode; return this; } public int getSubclassFetchMode() { return _state.subclassMode; } public int getSubclassFetchMode(ClassMapping cls) { if (cls == null) return _state.subclassMode; int mode = cls.getSubclassFetchMode(); if (mode == DEFAULT) return _state.subclassMode; return Math.min(mode, _state.subclassMode); } public JDBCFetchConfiguration setSubclassFetchMode(int mode) { if (mode != DEFAULT && mode != EagerFetchModes.EAGER_NONE && mode != EagerFetchModes.EAGER_JOIN && mode != EagerFetchModes.EAGER_PARALLEL) throw new IllegalArgumentException(_loc.get("bad-fetch-mode", Integer.valueOf(mode)).getMessage()); if (mode == DEFAULT) { JDBCConfiguration conf = getJDBCConfiguration(); if (conf != null) mode = conf.getSubclassFetchModeConstant(); } if (mode != DEFAULT) _state.subclassMode = mode; return this; } public int getResultSetType() { return _state.type; } public JDBCFetchConfiguration setResultSetType(int type) { if (type != DEFAULT && type != ResultSet.TYPE_FORWARD_ONLY && type != ResultSet.TYPE_SCROLL_INSENSITIVE && type != ResultSet.TYPE_SCROLL_SENSITIVE) throw new IllegalArgumentException(_loc.get("bad-resultset-type", Integer.valueOf(type)).getMessage()); if (type == DEFAULT) { JDBCConfiguration conf = getJDBCConfiguration(); if (conf != null) _state.type = conf.getResultSetTypeConstant(); } else _state.type = type; return this; } public int getFetchDirection() { return _state.direction; } public JDBCFetchConfiguration setFetchDirection(int direction) { if (direction != DEFAULT && direction != ResultSet.FETCH_FORWARD && direction != ResultSet.FETCH_REVERSE && direction != ResultSet.FETCH_UNKNOWN) throw new IllegalArgumentException( _loc.get("bad-fetch-direction", Integer.valueOf(direction)).getMessage()); if (direction == DEFAULT) { JDBCConfiguration conf = getJDBCConfiguration(); if (conf != null) _state.direction = conf.getFetchDirectionConstant(); } else _state.direction = direction; return this; } public int getLRSSize() { return _state.size; } public JDBCFetchConfiguration setLRSSize(int size) { if (size != DEFAULT && size != LRSSizes.SIZE_QUERY && size != LRSSizes.SIZE_LAST && size != LRSSizes.SIZE_UNKNOWN) throw new IllegalArgumentException(_loc.get("bad-lrs-size", Integer.valueOf(size)).getMessage()); if (size == DEFAULT) { JDBCConfiguration conf = getJDBCConfiguration(); if (conf != null) _state.size = conf.getLRSSizeConstant(); } else _state.size = size; return this; } public int getJoinSyntax() { return _state.syntax; } public JDBCFetchConfiguration setJoinSyntax(int syntax) { if (syntax != DEFAULT && syntax != JoinSyntaxes.SYNTAX_SQL92 && syntax != JoinSyntaxes.SYNTAX_TRADITIONAL && syntax != JoinSyntaxes.SYNTAX_DATABASE) throw new IllegalArgumentException(_loc.get("bad-join-syntax", Integer.valueOf(syntax)).getMessage()); if (syntax == DEFAULT) { JDBCConfiguration conf = getJDBCConfiguration(); if (conf != null) _state.syntax = conf.getDBDictionaryInstance().joinSyntax; } else _state.syntax = syntax; return this; } public ResultList<?> newResultList(ResultObjectProvider rop) { // if built around a list, just use a simple wrapper if (rop instanceof ListResultObjectProvider) return new SimpleResultList(rop); // if built around a paging list, use a window provider with the // same window size if (rop instanceof PagingResultObjectProvider) return new WindowResultList(rop, ((PagingResultObjectProvider) rop).getPageSize()); // if fetch size < 0 just read in all results immediately if (getFetchBatchSize() < 0) return new EagerResultList(rop); // if foward only or forward direction use a forward window if (_state.type == ResultSet.TYPE_FORWARD_ONLY || _state.direction == ResultSet.FETCH_FORWARD || !rop.supportsRandomAccess()) { if (getFetchBatchSize() > 0 && getFetchBatchSize() <= 50) return new WindowResultList(rop, getFetchBatchSize()); return new WindowResultList(rop, 50); } // if skipping around use a caching random access list if (_state.direction == ResultSet.FETCH_UNKNOWN) return new SoftRandomAccessResultList(rop); // scrolling reverse... just use non-caching simple result list return new SimpleResultList(rop); } public Set<String> getJoins() { if (_state.joins == null) return Collections.emptySet(); return _state.joins; } public boolean hasJoin(String field) { return _state.joins != null && _state.joins.contains(field); } public JDBCFetchConfiguration addJoin(String join) { if (StringUtils.isEmpty(join)) throw new UserException(_loc.get("null-join")); lock(); try { if (_state.joins == null) _state.joins = new HashSet<String>(); _state.joins.add(join); } finally { unlock(); } return this; } public JDBCFetchConfiguration addJoins(Collection<String> joins) { if (joins == null || joins.isEmpty()) return this; for (Iterator<String> itr = joins.iterator(); itr.hasNext();) addJoin(itr.next()); return this; } public JDBCFetchConfiguration removeJoin(String field) { lock(); try { if (_state.joins != null) _state.joins.remove(field); } finally { unlock(); } return this; } public JDBCFetchConfiguration removeJoins(Collection<String> joins) { lock(); try { if (_state.joins != null) _state.joins.removeAll(joins); } finally { unlock(); } return this; } public JDBCFetchConfiguration clearJoins() { lock(); try { if (_state.joins != null) _state.joins.clear(); } finally { unlock(); } return this; } public int getIsolation() { return _state.isolationLevel; } public JDBCFetchConfiguration setIsolation(int level) { if (level != -1 && level != DEFAULT && level != Connection.TRANSACTION_NONE && level != Connection.TRANSACTION_READ_UNCOMMITTED && level != Connection.TRANSACTION_READ_COMMITTED && level != Connection.TRANSACTION_REPEATABLE_READ && level != Connection.TRANSACTION_SERIALIZABLE) throw new IllegalArgumentException(_loc.get("bad-level", Integer.valueOf(level)).getMessage()); if (level == DEFAULT) _state.isolationLevel = -1; else _state.isolationLevel = level; return this; } public JDBCFetchConfiguration traverseJDBC(FieldMetaData fm) { return (JDBCFetchConfiguration) traverse(fm); } /** * Access JDBC configuration information. May return null if not a * JDBC back-end (possible to get a JDBCFetchConfiguration on non-JDBC * back end in remote client). */ private JDBCConfiguration getJDBCConfiguration() { StoreContext ctx = getContext(); if (ctx == null) return null; OpenJPAConfiguration conf = ctx.getConfiguration(); if (!(conf instanceof JDBCConfiguration)) return null; return (JDBCConfiguration) conf; } public Set<String> getFetchInnerJoins() { if (_state.fetchInnerJoins == null) return Collections.emptySet(); return _state.fetchInnerJoins; } public boolean hasFetchInnerJoin(String field) { return _state.fetchInnerJoins != null && _state.fetchInnerJoins.contains(field); } public JDBCFetchConfiguration addFetchInnerJoin(String join) { if (StringUtils.isEmpty(join)) throw new UserException(_loc.get("null-join")); lock(); try { if (_state.fetchInnerJoins == null) _state.fetchInnerJoins = new HashSet<String>(); _state.fetchInnerJoins.add(join); } finally { unlock(); } return this; } public JDBCFetchConfiguration addFetchInnerJoins(Collection<String> joins) { if (joins == null || joins.isEmpty()) return this; for (Iterator<String> itr = joins.iterator(); itr.hasNext();) addFetchInnerJoin((String) itr.next()); return this; } }