0001: /*
0002: * Licensed to the Apache Software Foundation (ASF) under one
0003: * or more contributor license agreements. See the NOTICE file
0004: * distributed with this work for additional information
0005: * regarding copyright ownership. The ASF licenses this file
0006: * to you under the Apache License, Version 2.0 (the
0007: * "License"); you may not use this file except in compliance
0008: * with the License. You may obtain a copy of the License at
0009: *
0010: * http://www.apache.org/licenses/LICENSE-2.0
0011: *
0012: * Unless required by applicable law or agreed to in writing,
0013: * software distributed under the License is distributed on an
0014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
0015: * KIND, either express or implied. See the License for the
0016: * specific language governing permissions and limitations
0017: * under the License.
0018: */
0019: package org.apache.openjpa.conf;
0020:
0021: import java.util.Collection;
0022: import java.util.Map;
0023:
0024: import org.apache.openjpa.datacache.DataCache;
0025: import org.apache.openjpa.datacache.DataCacheManager;
0026: import org.apache.openjpa.ee.ManagedRuntime;
0027: import org.apache.openjpa.event.OrphanedKeyAction;
0028: import org.apache.openjpa.event.RemoteCommitEventManager;
0029: import org.apache.openjpa.event.RemoteCommitProvider;
0030: import org.apache.openjpa.kernel.AutoClear;
0031: import org.apache.openjpa.kernel.AutoDetach;
0032: import org.apache.openjpa.kernel.BrokerFactory;
0033: import org.apache.openjpa.kernel.BrokerImpl;
0034: import org.apache.openjpa.kernel.ConnectionRetainModes;
0035: import org.apache.openjpa.kernel.FetchConfiguration;
0036: import org.apache.openjpa.kernel.InverseManager;
0037: import org.apache.openjpa.kernel.LockManager;
0038: import org.apache.openjpa.kernel.QueryFlushModes;
0039: import org.apache.openjpa.kernel.RestoreState;
0040: import org.apache.openjpa.kernel.SavepointManager;
0041: import org.apache.openjpa.kernel.Seq;
0042: import org.apache.openjpa.event.BrokerFactoryEventManager;
0043: import org.apache.openjpa.kernel.exps.AggregateListener;
0044: import org.apache.openjpa.kernel.exps.FilterListener;
0045: import org.apache.openjpa.lib.conf.Configuration;
0046: import org.apache.openjpa.meta.MetaDataFactory;
0047: import org.apache.openjpa.meta.MetaDataRepository;
0048: import org.apache.openjpa.util.ClassResolver;
0049: import org.apache.openjpa.util.ProxyManager;
0050: import org.apache.openjpa.util.StoreFacadeTypeRegistry;
0051:
0052: /**
0053: * Defines the properties necessary to configure runtime properties and
0054: * connect to a data source. There is a 1-1 relation between a configuration
0055: * and a {@link BrokerFactory}.
0056: * All setter methods that take primitive parameters also have wrapper
0057: * setter with the appropriate primitive wrapper. This is so the interface
0058: * can be in accordance with the J2EE Connector Architecture.
0059: *
0060: * @author Marc Prud'hommeaux
0061: * @author Abe White
0062: * @see Configuration
0063: */
0064: public interface OpenJPAConfiguration extends Configuration {
0065:
0066: /**
0067: * Name of logger for metadata-related messages:
0068: * <code>openjpa.MetaData</code>.
0069: */
0070: public static final String LOG_METADATA = "openjpa.MetaData";
0071:
0072: /**
0073: * Name of logger for enhancement-related messages:
0074: * <code>openjpa.Enhance</code>.
0075: */
0076: public static final String LOG_ENHANCE = "openjpa.Enhance";
0077:
0078: /**
0079: * Name of logger for messages from the runtime system:
0080: * <code>openjpa.Runtime</code>.
0081: */
0082: public static final String LOG_RUNTIME = "openjpa.Runtime";
0083:
0084: /**
0085: * Name of logger for query logging:
0086: * <code>openjpa.Query</code>.
0087: */
0088: public static final String LOG_QUERY = "openjpa.Query";
0089:
0090: /**
0091: * Name of logger for messages from the data cache:
0092: * <code>openjpa.DataCache</code>.
0093: */
0094: public static final String LOG_DATACACHE = "openjpa.DataCache";
0095:
0096: /**
0097: * Name of logger for messages from the development tools:
0098: * <code>openjpa.Tool</code>.
0099: */
0100: public static final String LOG_TOOL = "openjpa.Tool";
0101:
0102: /**
0103: * Option for runtimes that support nontransactional reads.
0104: */
0105: public static final String OPTION_NONTRANS_READ = "openjpa.option.NontransactionalRead";
0106:
0107: /**
0108: * Option for runtimes that support optimistic transactions.
0109: */
0110: public static final String OPTION_OPTIMISTIC = "openjpa.option.Optimistic";
0111:
0112: /**
0113: * Option for runtimes that support application identity.
0114: */
0115: public static final String OPTION_ID_APPLICATION = "openjpa.option.ApplicationIdentity";
0116:
0117: /**
0118: * Option for runtimes that support application identity.
0119: */
0120: public static final String OPTION_ID_DATASTORE = "openjpa.option.DatastoreIdentity";
0121:
0122: /**
0123: * Option for SQL support.
0124: */
0125: public static final String OPTION_QUERY_SQL = "openjpa.option.SQL";
0126:
0127: /**
0128: * Option for runtimes that support persistent collection fields.
0129: */
0130: public static final String OPTION_TYPE_COLLECTION = "openjpa.option.Collection";
0131:
0132: /**
0133: * Option for runtimes that support persistent map fields.
0134: */
0135: public static final String OPTION_TYPE_MAP = "openjpa.option.Map";
0136:
0137: /**
0138: * Option for runtimes that support persistent array fields.
0139: */
0140: public static final String OPTION_TYPE_ARRAY = "openjpa.option.Array";
0141:
0142: /**
0143: * Option for runtime that can differentiate between null and empty
0144: * container fields.
0145: */
0146: public static final String OPTION_NULL_CONTAINER = "openjpa.option.NullContainer";
0147:
0148: /**
0149: * Option for runtimes that support embedded relations to other
0150: * persistence capable objects.
0151: */
0152: public static final String OPTION_EMBEDDED_RELATION = "openjpa.option.EmbeddedRelation";
0153:
0154: /**
0155: * Option for runtimes that support collections of embedded
0156: * relations to other persistence capable objects.
0157: */
0158: public static final String OPTION_EMBEDDED_COLLECTION_RELATION = "openjpa.option.EmbeddedCollectionRelation";
0159:
0160: /**
0161: * Option for runtimes that support maps of embedded
0162: * relations to other persistence capable objects.
0163: */
0164: public static final String OPTION_EMBEDDED_MAP_RELATION = "openjpa.option.EmbeddedMapRelation";
0165:
0166: /**
0167: * Option for runtimes that support incremental flushing.
0168: */
0169: public static final String OPTION_INC_FLUSH = "openjpa.option.IncrementalFlush";
0170:
0171: /**
0172: * Option for runtimes that the autoassign value strategy.
0173: */
0174: public static final String OPTION_VALUE_AUTOASSIGN = "openjpa.option.AutoassignValue";
0175:
0176: /**
0177: * Option for runtimes that the increment value strategy.
0178: */
0179: public static final String OPTION_VALUE_INCREMENT = "openjpa.option.IncrementValue";
0180:
0181: /**
0182: * Option for runtimes that support returning the datastore connection.
0183: */
0184: public static final String OPTION_DATASTORE_CONNECTION = "openjpa.option.DataStoreConnection";
0185:
0186: /**
0187: * Option for runtimes that support returning the datastore connection
0188: * that is a JDBC Connection.
0189: */
0190: public static final String OPTION_JDBC_CONNECTION = "openjpa.option.JDBCConnection";
0191:
0192: /**
0193: * Return the set of option strings supported by this runtime. This set
0194: * is mutable.
0195: */
0196: public Collection supportedOptions();
0197:
0198: /**
0199: * A configuration can be set with defaults for a specific specification.
0200: */
0201: public String getSpecification();
0202:
0203: /**
0204: * Set the specification that this configuration should use for the
0205: * various properties that need to have different defaults for different
0206: * spec environments. This should be invoked before any configuration
0207: * options are set, as it will mutate various values.
0208: * You can only assign the specification once, though it is not fatal
0209: * to attempt to do so multiple times. Attempts to set to null will
0210: * be ignored.
0211: */
0212: public boolean setSpecification(String spec);
0213:
0214: /**
0215: * The plugin string for the {@link ClassResolver} to use for custom
0216: * class loading.
0217: */
0218: public String getClassResolver();
0219:
0220: /**
0221: * The plugin string for the {@link ClassResolver} to use for custom
0222: * class loading.
0223: */
0224: public void setClassResolver(String classResolver);
0225:
0226: /**
0227: * The {@link ClassResolver} to use.
0228: */
0229: public ClassResolver getClassResolverInstance();
0230:
0231: /**
0232: * The {@link ClassResolver} to use.
0233: */
0234: public void setClassResolver(ClassResolver classResolver);
0235:
0236: /**
0237: * The {@link BrokerFactory} class to use.
0238: */
0239: public String getBrokerFactory();
0240:
0241: /**
0242: * The {@link BrokerFactory} class to use.
0243: */
0244: public void setBrokerFactory(String factory);
0245:
0246: /**
0247: * The plugin string of the {@link BrokerImpl} extension to create.
0248: */
0249: public String getBrokerImpl();
0250:
0251: /**
0252: * The plugin string of the {@link BrokerImpl} extension to create.
0253: */
0254: public void setBrokerImpl(String broker);
0255:
0256: /**
0257: * Create a new broker instance with the configured plugin data.
0258: */
0259: public BrokerImpl newBrokerInstance(String user, String pass);
0260:
0261: /**
0262: * The {@link DataCache} to use for level-2 data store caching.
0263: */
0264: public String getDataCache();
0265:
0266: /**
0267: * The {@link DataCache} to use for level-2 data store caching.
0268: */
0269: public void setDataCache(String dataCache);
0270:
0271: /**
0272: * The data cache manager manages this configuration's cache instances.
0273: */
0274: public String getDataCacheManager();
0275:
0276: /**
0277: * The data cache manager manages this configuration's cache instances.
0278: */
0279: public void setDataCacheManager(String mgr);
0280:
0281: /**
0282: * The data cache manager manages this configuration's cache instances.
0283: * The cache manager is created if it has not been set. Once the cache
0284: * manager has been set/created, all changes to caching configuration
0285: * must proceed through the cache manager.
0286: *
0287: * @since 0.3.0
0288: */
0289: public DataCacheManager getDataCacheManagerInstance();
0290:
0291: /**
0292: * The data cache manager manages this configuration's cache instances.
0293: *
0294: * @since 0.3.0
0295: */
0296: public void setDataCacheManager(DataCacheManager manager);
0297:
0298: /**
0299: * Default data cache timeout.
0300: *
0301: * @since 0.2.5
0302: */
0303: public int getDataCacheTimeout();
0304:
0305: /**
0306: * Default data cache timeout.
0307: *
0308: * @since 0.2.5
0309: */
0310: public void setDataCacheTimeout(int timeout);
0311:
0312: /**
0313: * Wrapper for JCA usage of {@link #setDataCacheTimeout(int)}.
0314: *
0315: * @since 0.2.5
0316: */
0317: public void setDataCacheTimeout(Integer timeout);
0318:
0319: /**
0320: * The plugin to use for level-2 data store query caching.
0321: *
0322: * @since 0.2.5
0323: */
0324: public String getQueryCache();
0325:
0326: /**
0327: * The plugin to use for level-2 data store query caching.
0328: *
0329: * @since 0.2.5
0330: */
0331: public void setQueryCache(String queryCache);
0332:
0333: /**
0334: * Return whether to generate dynamic data structures
0335: * where possible for cache and runtime usage.
0336: *
0337: * @since 0.3.3
0338: */
0339: public boolean getDynamicDataStructs();
0340:
0341: /**
0342: * Set whether to generate dynamic data structures
0343: * where possible for cache and runtime usage.
0344: *
0345: * @since 0.3.3
0346: */
0347: public void setDynamicDataStructs(boolean dynamic);
0348:
0349: /**
0350: * Wrapper for JCA usage of {@link #setDynamicDataStructs(boolean)}.
0351: */
0352: public void setDynamicDataStructs(Boolean dynamic);
0353:
0354: /**
0355: * The plugin to use for datastore lock management.
0356: *
0357: * @since 0.3.1
0358: */
0359: public String getLockManager();
0360:
0361: /**
0362: * The plugin to use for datastore lock management.
0363: *
0364: * @since 0.3.1
0365: */
0366: public void setLockManager(String lockManager);
0367:
0368: /**
0369: * Return a new lock manager instance using the configured plugin settings.
0370: */
0371: public LockManager newLockManagerInstance();
0372:
0373: /**
0374: * The plugin to use for managing inverse relations.
0375: *
0376: * @since 0.3.2
0377: */
0378: public String getInverseManager();
0379:
0380: /**
0381: * The plugin to use for managing inverse relations.
0382: *
0383: * @since 0.3.2
0384: */
0385: public void setInverseManager(String inverse);
0386:
0387: /**
0388: * Return a new inverse manager instance using the configured plugin
0389: * settings.
0390: *
0391: * @since 0.3.2
0392: */
0393: public InverseManager newInverseManagerInstance();
0394:
0395: /**
0396: * The plugin to use for savepoint management.
0397: *
0398: * @since 0.3.4
0399: */
0400: public String getSavepointManager();
0401:
0402: /**
0403: * The plugin to use for savepoint management.
0404: *
0405: * @since 0.3.4
0406: */
0407: public void setSavepointManager(String savepointManager);
0408:
0409: /**
0410: * Return the configured savepoint manager instance.
0411: */
0412: public SavepointManager getSavepointManagerInstance();
0413:
0414: /**
0415: * The action to take when an orphaned key is detected.
0416: *
0417: * @since 0.3.2.2
0418: */
0419: public String getOrphanedKeyAction();
0420:
0421: /**
0422: * The action to take when an orphaned key is detected.
0423: *
0424: * @since 0.3.2.2
0425: */
0426: public void setOrphanedKeyAction(String action);
0427:
0428: /**
0429: * The action to take when an orphaned key is detected.
0430: *
0431: * @since 0.3.2.2
0432: */
0433: public OrphanedKeyAction getOrphanedKeyActionInstance();
0434:
0435: /**
0436: * The action to take when an orphaned key is detected.
0437: *
0438: * @since 0.3.2.2
0439: */
0440: public void setOrphanedKeyAction(OrphanedKeyAction action);
0441:
0442: /**
0443: * The plugin to use for remote commit notification.
0444: *
0445: * @since 0.2.5
0446: */
0447: public String getRemoteCommitProvider();
0448:
0449: /**
0450: * The plugin to use for remote commit notification.
0451: *
0452: * @since 0.2.5
0453: */
0454: public void setRemoteCommitProvider(String remoteCommitProvider);
0455:
0456: /**
0457: * Create a remote commit provider from the configured plugin.
0458: *
0459: * @since 0.3.0
0460: */
0461: public RemoteCommitProvider newRemoteCommitProviderInstance();
0462:
0463: /**
0464: * The remote event manager that manages this configuration's remote
0465: * event listeners.
0466: *
0467: * @since 0.3.0
0468: */
0469: public RemoteCommitEventManager getRemoteCommitEventManager();
0470:
0471: /**
0472: * The remote event manager that manages this configuration's remote
0473: * event listeners.
0474: *
0475: * @since 0.3.0
0476: */
0477: public void setRemoteCommitEventManager(
0478: RemoteCommitEventManager manager);
0479:
0480: /**
0481: * Specifies the behavior of the transaction model. Possible values are:
0482: * <ul>
0483: * <li><code>local</code>: Perform transaction operations locally.</li>
0484: * <li><code>managed</code>: Use managed environment's global
0485: * transactions.</li>
0486: * </ul>
0487: *
0488: * @since 0.2.5
0489: */
0490: public String getTransactionMode();
0491:
0492: /**
0493: * Specifies the behavior of the transaction model. Possible values are:
0494: * <ul>
0495: * <li><code>local</code>: Perform transaction operations locally.</li>
0496: * <li><code>managed</code>: Use managed environment's global
0497: * transactions.</li>
0498: * </ul>
0499: *
0500: * @since 0.2.5
0501: */
0502: public void setTransactionMode(String mode);
0503:
0504: /**
0505: * Return whether managed transactions are being used.
0506: */
0507: public boolean isTransactionModeManaged();
0508:
0509: /**
0510: * Set whether managed transactions are being used.
0511: */
0512: public void setTransactionModeManaged(boolean managed);
0513:
0514: /**
0515: * The plugin string for the {@link ManagedRuntime} to use for managed
0516: * environments.
0517: */
0518: public String getManagedRuntime();
0519:
0520: /**
0521: * The plugin string for the {@link ManagedRuntime} to use for managed
0522: * environments.
0523: */
0524: public void setManagedRuntime(String managedRuntime);
0525:
0526: /**
0527: * The plugin to use for integrating with a managed runtime.
0528: */
0529: public ManagedRuntime getManagedRuntimeInstance();
0530:
0531: /**
0532: * The plugin to use for integrating with a managed runtime.
0533: */
0534: public void setManagedRuntime(ManagedRuntime runtime);
0535:
0536: /**
0537: * The plugin string for the {@link ProxyManager} to use for second
0538: * class object proxies.
0539: */
0540: public String getProxyManager();
0541:
0542: /**
0543: * The plugin string for the {@link ProxyManager} to use for second
0544: * class object proxies.
0545: */
0546: public void setProxyManager(String proxyManager);
0547:
0548: /**
0549: * The {@link ProxyManager} to use.
0550: */
0551: public ProxyManager getProxyManagerInstance();
0552:
0553: /**
0554: * The {@link ProxyManager} to use.
0555: */
0556: public void setProxyManager(ProxyManager manager);
0557:
0558: /**
0559: * The name mapping to use for this data store.
0560: */
0561: public String getMapping();
0562:
0563: /**
0564: * The name mapping to use for this data store.
0565: */
0566: public void setMapping(String mapping);
0567:
0568: /**
0569: * A plugin string describing the {@link MetaDataFactory} to use.
0570: */
0571: public String getMetaDataFactory();
0572:
0573: /**
0574: * A plugin string describing the {@link MetaDataFactory} to use.
0575: */
0576: public void setMetaDataFactory(String meta);
0577:
0578: /**
0579: * Create a new {@link MetaDataFactory} to use with a repository.
0580: */
0581: public MetaDataFactory newMetaDataFactoryInstance();
0582:
0583: /**
0584: * A plugin string describing the {@link MetaDataRepository} to use.
0585: */
0586: public String getMetaDataRepository();
0587:
0588: /**
0589: * A plugin string describing the {@link MetaDataRepository} to use.
0590: */
0591: public void setMetaDataRepository(String meta);
0592:
0593: /**
0594: * The metadata repository of managed class information. If no
0595: * repository has been set, creates one.
0596: *
0597: * @since 0.3.0
0598: */
0599: public MetaDataRepository getMetaDataRepositoryInstance();
0600:
0601: /**
0602: * Returns true if a metaDataRepository has been created for this
0603: * configuration.
0604: *
0605: * @since 1.1.0 1.0.1
0606: */
0607: public boolean metaDataRepositoryAvailable();
0608:
0609: /**
0610: * Create a new empty metadata repository of the configured type.
0611: */
0612: public MetaDataRepository newMetaDataRepositoryInstance();
0613:
0614: /**
0615: * The metadata repository of managed class information.
0616: *
0617: * @since 0.3.0
0618: */
0619: public void setMetaDataRepository(MetaDataRepository mdRepos);
0620:
0621: /**
0622: * The user name for the data store connection.
0623: */
0624: public String getConnectionUserName();
0625:
0626: /**
0627: * The user name for the data store connection.
0628: */
0629: public void setConnectionUserName(String connectionUserName);
0630:
0631: /**
0632: * The password for the data store connection.
0633: */
0634: public String getConnectionPassword();
0635:
0636: /**
0637: * The password for the data store connection.
0638: */
0639: public void setConnectionPassword(String connectionPassword);
0640:
0641: /**
0642: * The URL for the data store connection.
0643: */
0644: public String getConnectionURL();
0645:
0646: /**
0647: * The URL for the data store connection.
0648: */
0649: public void setConnectionURL(String connectionURL);
0650:
0651: /**
0652: * Class name of the connection driver.
0653: */
0654: public String getConnectionDriverName();
0655:
0656: /**
0657: * Class name of the connection driver.
0658: */
0659: public void setConnectionDriverName(String driverName);
0660:
0661: /**
0662: * The name for the data store connection factory.
0663: */
0664: public String getConnectionFactoryName();
0665:
0666: /**
0667: * The name for the data store connection factory.
0668: */
0669: public void setConnectionFactoryName(String cfName);
0670:
0671: /**
0672: * The connection factory, possibly from JNDI.
0673: */
0674: public Object getConnectionFactory();
0675:
0676: /**
0677: * The connection factory.
0678: */
0679: public void setConnectionFactory(Object factory);
0680:
0681: /**
0682: * These properties provide any additional information needed to
0683: * establish connections.
0684: */
0685: public String getConnectionProperties();
0686:
0687: /**
0688: * These properties provide any additional information needed to
0689: * establish connections.
0690: */
0691: public void setConnectionProperties(String props);
0692:
0693: /**
0694: * Configuration properties for the connection factory.
0695: */
0696: public String getConnectionFactoryProperties();
0697:
0698: /**
0699: * Configuration properties for the connection factory.
0700: */
0701: public void setConnectionFactoryProperties(String props);
0702:
0703: /**
0704: * The mode of the connection factory in use. Available options are:
0705: * <ul>
0706: * <li>local: OpenJPA controls the connections.</li>
0707: * <li>managed: Connections are automatically enlisted in
0708: * the current global transaction by an application server.</li>
0709: * </ul> Defaults to local.
0710: */
0711: public String getConnectionFactoryMode();
0712:
0713: /**
0714: * The mode of the connection factory in use. Available options are:
0715: * <ul>
0716: * <li>local: OpenJPA controls the connections.</li>
0717: * <li>managed: Connections are automatically enlisted in
0718: * the current global transaction by an application server.</li>
0719: * </ul> Defaults to local.
0720: */
0721: public void setConnectionFactoryMode(String mode);
0722:
0723: /**
0724: * Whether connections are automatically enlisted in global transactions.
0725: */
0726: public boolean isConnectionFactoryModeManaged();
0727:
0728: /**
0729: * Whether connections are automatically enlisted in global transactions.
0730: */
0731: public void setConnectionFactoryModeManaged(boolean managed);
0732:
0733: /**
0734: * The user name for the non-XA data store connection.
0735: */
0736: public String getConnection2UserName();
0737:
0738: /**
0739: * The user name for the non-XA data store connection.
0740: */
0741: public void setConnection2UserName(String connectionUserName);
0742:
0743: /**
0744: * The password for the non-XA data store connection.
0745: */
0746: public String getConnection2Password();
0747:
0748: /**
0749: * The password for the non-XA data store connection.
0750: */
0751: public void setConnection2Password(String connectionPassword);
0752:
0753: /**
0754: * The URL for the non-XA data store connection.
0755: */
0756: public String getConnection2URL();
0757:
0758: /**
0759: * The URL for the non-XA data store connection.
0760: */
0761: public void setConnection2URL(String connectionURL);
0762:
0763: /**
0764: * Class name of the non-XA connection driver.
0765: */
0766: public String getConnection2DriverName();
0767:
0768: /**
0769: * Class name of the non-XA connection driver.
0770: */
0771: public void setConnection2DriverName(String driverName);
0772:
0773: /**
0774: * The name for the second data store connection factory.
0775: */
0776: public String getConnectionFactory2Name();
0777:
0778: /**
0779: * The name for the second data store connection factory.
0780: */
0781: public void setConnectionFactory2Name(String cf2Name);
0782:
0783: /**
0784: * The non-XA connection factory.
0785: */
0786: public Object getConnectionFactory2();
0787:
0788: /**
0789: * The non-XA connection factory.
0790: */
0791: public void setConnectionFactory2(Object factory);
0792:
0793: /**
0794: * These properties provide any additional information needed to
0795: * establish non-XA connections.
0796: *
0797: * @since 0.3.0
0798: */
0799: public String getConnection2Properties();
0800:
0801: /**
0802: * These properties provide any additional information needed to
0803: * establish non-XA connections.
0804: *
0805: * @since 0.3.0
0806: */
0807: public void setConnection2Properties(String props);
0808:
0809: /**
0810: * Configuration properties for the non-XA connection factory.
0811: *
0812: * @since 0.2.5
0813: */
0814: public String getConnectionFactory2Properties();
0815:
0816: /**
0817: * Configuration properties for the non-XA connection factory.
0818: *
0819: * @since 0.2.5
0820: */
0821: public void setConnectionFactory2Properties(String props);
0822:
0823: /**
0824: * Whether to use optimistic transactions by default.
0825: */
0826: public boolean getOptimistic();
0827:
0828: /**
0829: * Whether to use optimistic transactions by default.
0830: */
0831: public void setOptimistic(boolean optimistic);
0832:
0833: /**
0834: * Wrapper for JCA usage of {@link #setOptimistic(boolean)}.
0835: */
0836: public void setOptimistic(Boolean optimistic);
0837:
0838: /**
0839: * Whether to retain state after a transaction by default.
0840: */
0841: public boolean getRetainState();
0842:
0843: /**
0844: * Whether to retain state after a transaction by default.
0845: */
0846: public void setRetainState(boolean retainState);
0847:
0848: /**
0849: * Wrapper for JCA usage of {@link #setRetainState(boolean)}.
0850: */
0851: public void setRetainState(Boolean retainState);
0852:
0853: /**
0854: * Whether instances clear their state when entering a transaction.
0855: */
0856: public String getAutoClear();
0857:
0858: /**
0859: * Whether instances clear their state when entering a transaction.
0860: */
0861: public void setAutoClear(String clear);
0862:
0863: /**
0864: * Return the {@link AutoClear} constant.
0865: */
0866: public int getAutoClearConstant();
0867:
0868: /**
0869: * Whether instances clear their state when entering a transaction.
0870: */
0871: public void setAutoClear(int clear);
0872:
0873: /**
0874: * Whether to restore initial state on rollback by default.
0875: */
0876: public String getRestoreState();
0877:
0878: /**
0879: * Whether to restore initial state on rollback by default.
0880: */
0881: public void setRestoreState(String restoreState);
0882:
0883: /**
0884: * Return the {@link RestoreState} constant.
0885: */
0886: public int getRestoreStateConstant();
0887:
0888: /**
0889: * Whether to restore initial state on rollback by default.
0890: */
0891: public void setRestoreState(int restoreState);
0892:
0893: /**
0894: * Whether changes in the current transaction are taken into account when
0895: * executing queries and iterating extents.
0896: */
0897: public boolean getIgnoreChanges();
0898:
0899: /**
0900: * Whether changes in the current transaction are taken into account when
0901: * executing queries and iterating extents.
0902: */
0903: public void setIgnoreChanges(boolean ignoreChanges);
0904:
0905: /**
0906: * Wrapper for JCA usage of {@link #setIgnoreChanges(boolean)}.
0907: */
0908: public void setIgnoreChanges(Boolean ignoreChanges);
0909:
0910: /**
0911: * A comma-separated list of events which trigger auto-detachment
0912: * in place of managed states. Possible values are:
0913: * <ul>
0914: * <li><code>commit</code>: When the current transaction commits.</li>
0915: * <li><code>close</code>: When the broker closes.</li>
0916: * <li><code>nontx-read</code>: When instances are read
0917: * non-transactionally.</li>
0918: * </ul>
0919: */
0920: public String getAutoDetach();
0921:
0922: /**
0923: * A comma-separated list of events which trigger auto-detachment
0924: * in place of managed states. Possible values are:
0925: * <ul>
0926: * <li><code>commit</code>: When the current transaction commits.</li>
0927: * <li><code>close</code>: When the broker closes.</li>
0928: * <li><code>nontx-read</code>: When instances are read
0929: * non-transactionally.</li>
0930: * </ul>
0931: */
0932: public void setAutoDetach(String detach);
0933:
0934: /**
0935: * The {@link AutoDetach} flags.
0936: */
0937: public int getAutoDetachConstant();
0938:
0939: /**
0940: * The {@link AutoDetach} flags.
0941: */
0942: public void setAutoDetach(int flags);
0943:
0944: /**
0945: * Which field values to include when detaching.
0946: */
0947: public void setDetachState(String detachState);
0948:
0949: /**
0950: * Return the instance specified by the detach state plugin.
0951: */
0952: public DetachOptions getDetachStateInstance();
0953:
0954: /**
0955: * Return the instance specified by the detach state plugin.
0956: */
0957: public void setDetachState(DetachOptions detachState);
0958:
0959: /**
0960: * Whether persistent state is accessible outside a transaction by default.
0961: */
0962: public boolean getNontransactionalRead();
0963:
0964: /**
0965: * Whether persistent state is accessible outside a transaction by default.
0966: */
0967: public void setNontransactionalRead(boolean ntRead);
0968:
0969: /**
0970: * Wrapper for JCA usage of {@link #setNontransactionalRead(boolean)}.
0971: */
0972: public void setNontransactionalRead(Boolean ntRead);
0973:
0974: /**
0975: * Whether persistent state can be modified outside a transaction by
0976: * default.
0977: */
0978: public boolean getNontransactionalWrite();
0979:
0980: /**
0981: * Whether persistent state can be modified outside a transaction by
0982: * default.
0983: */
0984: public void setNontransactionalWrite(boolean ntWrite);
0985:
0986: /**
0987: * Wrapper for JCA usage of {@link #setNontransactionalWrite(boolean)}.
0988: */
0989: public void setNontransactionalWrite(Boolean ntWrite);
0990:
0991: /**
0992: * Whether brokers or their managed objects will be used by multiple
0993: * concurrent threads.
0994: */
0995: public boolean getMultithreaded();
0996:
0997: /**
0998: * Whether brokers or their managed objects will be used by multiple
0999: * concurrent threads.
1000: */
1001: public void setMultithreaded(boolean multithreaded);
1002:
1003: /**
1004: * Wrapper for JCA usage of {@link #setMultithreaded(boolean)}.
1005: */
1006: public void setMultithreaded(Boolean multithreaded);
1007:
1008: /**
1009: * Get the size of the batch that will be pre-selected when accessing
1010: * elements in a query or relationship. Use -1 to prefetch all results.
1011: */
1012: public int getFetchBatchSize();
1013:
1014: /**
1015: * Set the size of the batch that will be pre-selected when accessing
1016: * elements in a query or relationship. Use -1 to prefetch all results.
1017: */
1018: public void setFetchBatchSize(int size);
1019:
1020: /**
1021: * Wrapper for JCA usage of {@link #setFetchBatchSize(int)}.
1022: */
1023: public void setFetchBatchSize(Integer size);
1024:
1025: /**
1026: * The maximum relation depth to traverse when eager fetching. Use
1027: * -1 for no limit.
1028: */
1029: public int getMaxFetchDepth();
1030:
1031: /**
1032: * The maximum relation depth to traverse when eager fetching. Use
1033: * -1 for no limit.
1034: */
1035: public void setMaxFetchDepth(int depth);
1036:
1037: /**
1038: * Wrapper for JCA usage of {@link #setMaxFetchDepth(int)}.
1039: */
1040: public void setMaxFetchDepth(Integer size);
1041:
1042: /**
1043: * Comma-separated list of fetch group names that will be pre-set for
1044: * all new {@link FetchConfiguration}s.
1045: *
1046: * @since 0.2.5
1047: */
1048: public String getFetchGroups();
1049:
1050: /**
1051: * Comma-separated list of fetch group names that will be pre-set for
1052: * all new {@link FetchConfiguration}s.
1053: *
1054: * @since 0.2.5
1055: */
1056: public void setFetchGroups(String groups);
1057:
1058: /**
1059: * List of fetch group names that will be pre-set for all new
1060: * {@link FetchConfiguration}s.
1061: */
1062: public String[] getFetchGroupsList();
1063:
1064: /**
1065: * List of fetch group names that will be pre-set for all new
1066: * {@link FetchConfiguration}s.
1067: */
1068: public void setFetchGroups(String[] names);
1069:
1070: /**
1071: * Returns whether or not OpenJPA should automatically flush
1072: * modifications to the data store before executing queries.
1073: *
1074: * @since 0.2.5
1075: */
1076: public String getFlushBeforeQueries();
1077:
1078: /**
1079: * Sets whether or not OpenJPA should automatically flush
1080: * modifications to the data store before executing queries.
1081: *
1082: * @since 0.2.5
1083: */
1084: public void setFlushBeforeQueries(String flush);
1085:
1086: /**
1087: * Returns one of {@link QueryFlushModes#FLUSH_TRUE},
1088: * {@link QueryFlushModes#FLUSH_FALSE}, or
1089: * {@link QueryFlushModes#FLUSH_WITH_CONNECTION}, as determined
1090: * by parsing the string returned by {@link #getFlushBeforeQueries}.
1091: *
1092: * @since 0.2.5
1093: */
1094: public int getFlushBeforeQueriesConstant();
1095:
1096: /**
1097: * Set to one of {@link QueryFlushModes#FLUSH_TRUE},
1098: * {@link QueryFlushModes#FLUSH_FALSE}, or
1099: * {@link QueryFlushModes#FLUSH_WITH_CONNECTION}.
1100: *
1101: * @since 0.2.5
1102: */
1103: public void setFlushBeforeQueries(int flushBeforeQueries);
1104:
1105: /**
1106: * The time to wait for an object lock in milliseconds, or -1 for no
1107: * timeout.
1108: *
1109: * @since 0.3.1
1110: */
1111: public int getLockTimeout();
1112:
1113: /**
1114: * The time to wait for an object lock in milliseconds, or -1 for no
1115: * timeout.
1116: *
1117: * @since 0.3.1
1118: */
1119: public void setLockTimeout(int timeout);
1120:
1121: /**
1122: * Wrapper for JCA usage of {@link #setLockTimeout(int)}.
1123: *
1124: * @since 0.3.1
1125: */
1126: public void setLockTimeout(Integer timeout);
1127:
1128: /**
1129: * The default read lock level to use during non-optimistic transactions.
1130: * Defaults to <code>read</code>.
1131: *
1132: * @since 0.3.1
1133: */
1134: public String getReadLockLevel();
1135:
1136: /**
1137: * The default read lock level to use during non-optimistic transactions.
1138: * Defaults to <code>read</code>.
1139: *
1140: * @since 0.3.1
1141: */
1142: public void setReadLockLevel(String level);
1143:
1144: /**
1145: * The numeric read lock level.
1146: *
1147: * @since 0.3.1
1148: */
1149: public int getReadLockLevelConstant();
1150:
1151: /**
1152: * The numeric read lock level.
1153: *
1154: * @since 0.3.1
1155: */
1156: public void setReadLockLevel(int level);
1157:
1158: /**
1159: * The default write lock level to use during non-optimistic transactions.
1160: * Defaults to <code>write</code>.
1161: *
1162: * @since 0.3.1
1163: */
1164: public String getWriteLockLevel();
1165:
1166: /**
1167: * The default write lock level to use during non-optimistic transactions.
1168: * Defaults to <code>write</code>.
1169: *
1170: * @since 0.3.1
1171: */
1172: public void setWriteLockLevel(String level);
1173:
1174: /**
1175: * The numeric write lock level.
1176: *
1177: * @since 0.3.1
1178: */
1179: public int getWriteLockLevelConstant();
1180:
1181: /**
1182: * The numeric write lock level.
1183: *
1184: * @since 0.3.1
1185: */
1186: public void setWriteLockLevel(int level);
1187:
1188: /**
1189: * Plugin string for the default system {@link Seq}.
1190: */
1191: public String getSequence();
1192:
1193: /**
1194: * Plugin string for the default system {@link Seq}.
1195: */
1196: public void setSequence(String sequence);
1197:
1198: /**
1199: * The default system sequence.
1200: */
1201: public Seq getSequenceInstance();
1202:
1203: /**
1204: * The default system sequence.
1205: */
1206: public void setSequence(Seq sequence);
1207:
1208: /**
1209: * Specifies the behavior of the broker with respect to data store
1210: * connections. Possible values are:
1211: * <ul>
1212: * <li><code>always</code>: Each broker obtains a single connection and
1213: * uses it until the broker is closed.</li>
1214: * <li><code>transaction</code>: A connection is obtained when each
1215: * transaction begins (optimistic or datastore), and is released
1216: * when the transaction completes.</li>
1217: * <li><code>on-demand</code>: Connections are obtained only when needed.
1218: * This is the default mode. It is equivalent to the previous option
1219: * when datastore transactions are used. For optimistic transactions,
1220: * though, it means that a connection will be retained only for
1221: * the duration of the data store commit process.</li>
1222: * </ul>
1223: *
1224: * @since 0.2.5
1225: */
1226: public String getConnectionRetainMode();
1227:
1228: /**
1229: * Specifies the behavior of the broker with respect to data store
1230: * connections. Possible values are:
1231: * <ul>
1232: * <li><code>always</code>: Each broker obtains a single connection and
1233: * uses it until the broker is closed.</li>
1234: * <li><code>transaction</code>: A connection is obtained when each
1235: * transaction begins (optimistic or datastore), and is released
1236: * when the transaction completes.</li>
1237: * <li><code>on-demand</code>: Connections are obtained only when needed.
1238: * This is the default mode. It is equivalent to the previous option
1239: * when datastore transactions are used. For optimistic transactions,
1240: * though, it means that a connection will be retained only for
1241: * the duration of the data store commit process.</li>
1242: * </ul>
1243: *
1244: * @since 0.2.5
1245: */
1246: public void setConnectionRetainMode(String mode);
1247:
1248: /**
1249: * Return the connection retain mode as one of the following symbolic
1250: * constants:
1251: * <ul>
1252: * <li>{@link ConnectionRetainModes#CONN_RETAIN_ALWAYS}</li>
1253: * <li>{@link ConnectionRetainModes#CONN_RETAIN_TRANS}</li>
1254: * <li>{@link ConnectionRetainModes#CONN_RETAIN_DEMAND}</li>
1255: * </ul>
1256: */
1257: public int getConnectionRetainModeConstant();
1258:
1259: /**
1260: * Set the connection retain mode as one of the following symbolic
1261: * constants:
1262: * <ul>
1263: * <li>{@link ConnectionRetainModes#CONN_RETAIN_ALWAYS}</li>
1264: * <li>{@link ConnectionRetainModes#CONN_RETAIN_TRANS}</li>
1265: * <li>{@link ConnectionRetainModes#CONN_RETAIN_DEMAND}</li>
1266: * </ul>
1267: */
1268: public void setConnectionRetainMode(int mode);
1269:
1270: /**
1271: * A comma-separted list of the plugin strings of the query
1272: * {@link FilterListener}s to use.
1273: */
1274: public String getFilterListeners();
1275:
1276: /**
1277: * A comma-separted list of the plugin strings of the query
1278: * {@link FilterListener}s to use.
1279: */
1280: public void setFilterListeners(String listeners);
1281:
1282: /**
1283: * Return the query filter listeners. If none have been set explicitly,
1284: * this method instantiates the listeners from the set plugin list.
1285: */
1286: public FilterListener[] getFilterListenerInstances();
1287:
1288: /**
1289: * Set the query filter listeners. Overrides the list of listener classes.
1290: */
1291: public void setFilterListeners(FilterListener[] listeners);
1292:
1293: /**
1294: * A comma-separted list of the plugin strings of the query
1295: * {@link AggregateListener}s to use.
1296: */
1297: public String getAggregateListeners();
1298:
1299: /**
1300: * A comma-separted list of the plugin strings of the query
1301: * {@link AggregateListener}s to use.
1302: */
1303: public void setAggregateListeners(String listeners);
1304:
1305: /**
1306: * Return the query function listeners. If none have been set explicitly,
1307: * this method instantiates the listeners from the set plugin list.
1308: */
1309: public AggregateListener[] getAggregateListenerInstances();
1310:
1311: /**
1312: * Set the query function listeners. Overrides the list of listener classes.
1313: */
1314: public void setAggregateListeners(AggregateListener[] listeners);
1315:
1316: /**
1317: * Whether to warn and defer registration instead of throwing an
1318: * exception when a registered persistent class cannot be processed.
1319: * Should only be set to true in complex classloader topologies.
1320: * Defaults to <code>false</code>.
1321: *
1322: * @since 0.3.2.3
1323: */
1324: public boolean getRetryClassRegistration();
1325:
1326: /**
1327: * Whether to warn and defer registration instead of throwing an
1328: * exception when a registered persistent class cannot be processed.
1329: * Should only be set to true in complex classloader topologies.
1330: * Defaults to <code>false</code>.
1331: *
1332: * @since 0.3.2.3
1333: */
1334: public void setRetryClassRegistration(boolean warn);
1335:
1336: /**
1337: * Wrapper for JCA usage of {@link #setRetryClassRegistration(boolean)}.
1338: *
1339: * @since 0.3.2.3
1340: */
1341: public void setRetryClassRegistration(Boolean warn);
1342:
1343: /**
1344: * Backwards compatibility options.
1345: */
1346: public String getCompatibility();
1347:
1348: /**
1349: * Backwards compatibility options.
1350: */
1351: public void setCompatibility(String compatibility);
1352:
1353: /**
1354: * Backwards compatibility options.
1355: */
1356: public Compatibility getCompatibilityInstance();
1357:
1358: /**
1359: * Configuration settings for the query compilation cache to use.
1360: * @see QueryCompilationCacheValue
1361: * @since 0.9.6
1362: */
1363: public String getQueryCompilationCache();
1364:
1365: /**
1366: * Configuration settings for the query compilation cache to use.
1367: * @see QueryCompilationCacheValue
1368: * @since 0.9.6
1369: */
1370: public void setQueryCompilationCache(String conf);
1371:
1372: /**
1373: * Configuration settings for the query compilation cache to use.
1374: * @see QueryCompilationCacheValue
1375: * @since 0.9.6
1376: */
1377: public Map getQueryCompilationCacheInstance();
1378:
1379: /**
1380: * Return the {@link StoreFacadeTypeRegistry} instance associated with this
1381: * configuration.
1382: */
1383: public StoreFacadeTypeRegistry getStoreFacadeTypeRegistry();
1384:
1385: /**
1386: * Return the {@link org.apache.openjpa.event.BrokerFactoryEventManager}
1387: * associated with this configuration.
1388: *
1389: * @since 1.0.0
1390: */
1391: public BrokerFactoryEventManager getBrokerFactoryEventManager();
1392:
1393: /**
1394: * Specifies how OpenJPA handles unenhanced types. Possible values are:
1395: * <ul>
1396: * <li><code>supported</code>: Runtime optimization of persistent types
1397: * is available. This is the default</li>
1398: * <li><code>unsupported</code>: Runtime optimization of persistent types
1399: * is not available. An exception will be thrown if the system loads with
1400: * persistent types that are not enhanced.</li>
1401: * <li><code>warn</code>: Runtime optimization of persistent types is
1402: * not available, but no exception will be thrown initially. A warning will
1403: * be logged instead. It is likely that the system will fail at a later
1404: * point. This might be suitable for environments with complex classloader
1405: * configurations.</li>
1406: * </ul>
1407: *
1408: * @since 1.0.0
1409: */
1410: public String getRuntimeUnenhancedClasses();
1411:
1412: /**
1413: * Specifies how OpenJPA handles unenhanced types.
1414: *
1415: * @see {@link #getRuntimeUnenhancedClasses()}
1416: * @since 1.0.0
1417: */
1418: public void setRuntimeUnenhancedClasses(String mode);
1419:
1420: /**
1421: * Return the runtime class optimization setting as one of the
1422: * following symbolic constants:
1423: * <ul>
1424: * <li>{@link RuntimeUnenhancedClasssesModes#SUPPORTED}</li>
1425: * <li>{@link RuntimeUnenhancedClasssesModes#UNSUPPORTED}</li>
1426: * <li>{@link RuntimeUnenhancedClasssesModes#WARN}</li>
1427: * </ul>
1428: *
1429: * @since 1.0.0
1430: */
1431: public int getRuntimeUnenhancedClassesConstant();
1432:
1433: /**
1434: * Set the runtime class optimization setting as one of the
1435: * following symbolic constants:
1436: * <ul>
1437: * <li>{@link RuntimeUnenhancedClasssesModes#SUPPORTED}</li>
1438: * <li>{@link RuntimeUnenhancedClasssesModes#UNSUPPORTED}</li>
1439: * <li>{@link RuntimeUnenhancedClasssesModes#WARN}</li>
1440: * </ul>
1441: *
1442: * @since 1.0.0
1443: */
1444: public void setRuntimeUnenhancedClasses(int mode);
1445:
1446: /**
1447: * A comma-separted list of the plugin strings specifying the
1448: * {@link CacheMarshaller}s to use.
1449: *
1450: * @since 1.1.0
1451: */
1452: public String getCacheMarshallers();
1453:
1454: /**
1455: * A comma-separted list of the plugin strings specifying the
1456: * {@link CacheMarshaller}s to use.
1457: *
1458: * @since 1.1.0
1459: */
1460: public void setCacheMarshallers(String marshallers);
1461:
1462: /**
1463: * Return the cache marshaller listeners.
1464: *
1465: * @since 1.1.0
1466: */
1467: public Map getCacheMarshallerInstances();
1468: }
|