/** * Commit the current transaction, writing any unflushed changes to the database. * * @throws IllegalStateException if isActive() is false. * @throws RollbackException if the commit fails. */ public void commit() { assertActive(); if (tx.getRollbackOnly()) { // This is thrown by the underlying transaction but we want to have a RollbackException here // so intercept it if (NucleusLogger.TRANSACTION.isDebugEnabled()) { NucleusLogger.TRANSACTION.debug(Localiser.msg("015020")); } throw new RollbackException(Localiser.msg("015020")); } try { tx.commit(); } catch (NucleusTransactionException nte) { Throwable cause = nte.getCause(); Throwable pe = null; if (cause instanceof NucleusException) { pe = NucleusJPAHelper.getJPAExceptionForNucleusException((NucleusException) cause); } else { pe = cause; } throw new RollbackException(Localiser.msg("015007"), pe); } catch (NucleusException ne) { throw NucleusJPAHelper.getJPAExceptionForNucleusException(ne); } }
/** * Method to check if an element is already persistent, or is managed by a different * ExecutionContext. If not persistent, this will persist it. * * @param ec execution context * @param element The element * @param fieldValues any initial field values to use if persisting the element * @return Whether the element was persisted during this call */ protected boolean validateElementForWriting( ExecutionContext ec, Object element, FieldValues fieldValues) { // TODO Pass in cascade flag and if element not present then throw exception // Check the element type for this collection if (!elementIsPersistentInterface && !validateElementType(ec.getClassLoaderResolver(), element)) { throw new ClassCastException( Localiser.msg( "056033", element.getClass().getName(), ownerMemberMetaData.getFullFieldName(), elementType)); } boolean persisted = false; if (elementsAreEmbedded || elementsAreSerialised) { // Element is embedded/serialised so has no id } else { ObjectProvider elementSM = ec.findObjectProvider(element); if (elementSM != null && elementSM.isEmbedded()) { // Element is already with ObjectProvider and is embedded in another field! throw new NucleusUserException( Localiser.msg("056028", ownerMemberMetaData.getFullFieldName(), element)); } persisted = SCOUtils.validateObjectForWriting(ec, element, fieldValues); } return persisted; }
/* * (non-Javadoc) * @see * org.datanucleus.store.rdbms.mapping.datastore.AbstractDatastoreMapping#getObject(java.sql.ResultSet, int) */ @Override public Object getObject(ResultSet resultSet, int param) { Object so = null; try { InputStream is = resultSet.getBinaryStream(param); if (!resultSet.wasNull()) { if (getJavaTypeMapping() instanceof FileMapping) { so = StreamableSpooler.instance().spoolStream(is); } else { // TODO Support other types throw new NucleusDataStoreException( "getObject unsupported for java type mapping of type " + getJavaTypeMapping()); } } } catch (IOException e) { throw new NucleusDataStoreException( Localiser.msg("055002", "Object", "" + param, column, e.getMessage()), e); } catch (SQLException e) { throw new NucleusDataStoreException( Localiser.msg("055002", "Object", "" + param, column, e.getMessage()), e); } return so; }
public void setString(PreparedStatement ps, int param, String value) { try { if (getDatastoreAdapter().supportsOption(DatastoreAdapter.BLOB_SET_USING_SETSTRING)) { if (value == null) { if (column.isDefaultable() && column.getDefaultValue() != null) { ps.setString(param, column.getDefaultValue().toString().trim()); } else { ps.setNull(param, getJDBCType()); } } else { ps.setString(param, value); } } else { if (value == null) { if (column != null && column.isDefaultable() && column.getDefaultValue() != null) { ps.setBlob(param, new BlobImpl(column.getDefaultValue().toString().trim())); } else { ps.setNull(param, getJDBCType()); } } else { ps.setBlob(param, new BlobImpl(value)); } } } catch (SQLException e) { throw new NucleusDataStoreException( Localiser.msg("055001", "String", "" + value, column, e.getMessage()), e); } catch (IOException e) { throw new NucleusDataStoreException( Localiser.msg("055001", "String", "" + value, column, e.getMessage()), e); } }
public int getSize(ObjectProvider ownerOP) { int numRows; String sizeStmt = getSizeStmt(); try { ExecutionContext ec = ownerOP.getExecutionContext(); ManagedConnection mconn = storeMgr.getConnection(ec); SQLController sqlControl = storeMgr.getSQLController(); try { PreparedStatement ps = sqlControl.getStatementForQuery(mconn, sizeStmt); try { int jdbcPosition = 1; jdbcPosition = BackingStoreHelper.populateOwnerInStatement(ownerOP, ec, ps, jdbcPosition, this); if (getElementInfo() != null && getElementInfo().length == 1) { // TODO Allow for multiple element types (e.g interface implementations) for (int i = 0; i < getElementInfo().length; i++) { if (getElementInfo()[i].getDiscriminatorMapping() != null) { jdbcPosition = BackingStoreHelper.populateElementDiscriminatorInStatement( ec, ps, jdbcPosition, true, getElementInfo()[i], clr); } } } if (getRelationDiscriminatorMapping() != null) { jdbcPosition = BackingStoreHelper.populateRelationDiscriminatorInStatement( ec, ps, jdbcPosition, this); } ResultSet rs = sqlControl.executeStatementQuery(ec, mconn, sizeStmt, ps); try { if (!rs.next()) { throw new NucleusDataStoreException(Localiser.msg("056007", sizeStmt)); } numRows = rs.getInt(1); JDBCUtils.logWarnings(rs); } finally { rs.close(); } } finally { sqlControl.closeStatement(mconn, ps); } } finally { mconn.release(); } } catch (SQLException e) { throw new NucleusDataStoreException(Localiser.msg("056007", sizeStmt), e); } return numRows; }
/** * Accessor for the MetaData for the specified class, read from annotations. The annotations can * be of any supported type. * * @param cls The class * @param pmd PackageMetaData to use as a parent * @param clr ClassLoader resolver * @return The ClassMetaData */ public AbstractClassMetaData getMetaDataForClass( Class cls, PackageMetaData pmd, ClassLoaderResolver clr) { if (cls == null) { return null; } Annotation[] annotations = cls.getAnnotations(); if (annotations == null || annotations.length == 0) { return null; } // Find an annotation reader for this classes annotations (if we have one) String readerClassName = null; for (int i = 0; i < annotations.length; i++) { String reader = annotationReaderLookup.get(annotations[i].annotationType().getName()); if (reader != null) { readerClassName = reader; break; } } if (readerClassName == null) { NucleusLogger.METADATA.debug(Localiser.msg("044202", cls.getName())); return null; } AnnotationReader reader = annotationReaders.get(readerClassName); if (reader == null) { // Try to create this AnnotationReader try { Class[] ctrArgs = new Class[] {ClassConstants.METADATA_MANAGER}; Object[] ctrParams = new Object[] {metadataMgr}; PluginManager pluginMgr = metadataMgr.getNucleusContext().getPluginManager(); reader = (AnnotationReader) pluginMgr.createExecutableExtension( "org.datanucleus.annotations", "reader", readerClassName, "reader", ctrArgs, ctrParams); annotationReaders.put( readerClassName, reader); // Save the annotation reader in case we have more of this type } catch (Exception e) { NucleusLogger.METADATA.warn( Localiser.msg("MetaData.AnnotationReaderNotFound", readerClassName)); return null; } } return reader.getMetaDataForClass(cls, pmd, clr); }
/** * Method to return this class/field managed object as a string. * * @return String version of this class/field managed object. */ public String toString() { MetaData metadata = getMetaData(); if (metadata instanceof ClassMetaData) { ClassMetaData cmd = (ClassMetaData) metadata; return Localiser.msg( "035004", name, tableName != null ? tableName : "(none)", cmd.getInheritanceMetaData().getStrategy().toString()); } else if (metadata instanceof AbstractMemberMetaData) { return Localiser.msg("035005", name, tableName); } else { return Localiser.msg("035004", name, tableName); } }
/* * (non-Javadoc) * @see org.datanucleus.store.rdbms.mapping.AbstractLargeBinaryRDBMSMapping#getObject(java.lang.Object, * int) */ @Override public Object getObject(ResultSet rs, int param) { byte[] bytes = null; try { // Retrieve the bytes of the object directly bytes = rs.getBytes(param); if (bytes == null) { return null; } } catch (SQLException sqle) { try { // Retrieve the bytes using the Blob (if getBytes not supported e.g HSQLDB 2.0) Blob blob = rs.getBlob(param); if (blob == null) { return null; } bytes = blob.getBytes(1, (int) blob.length()); if (bytes == null) { return null; } } catch (SQLException sqle2) { throw new NucleusDataStoreException( Localiser.msg("055002", "Object", "" + param, column, sqle2.getMessage()), sqle2); } } return getObjectForBytes(bytes, param); }
/** * Method to remove an element from the ArrayList. * * @param index The element position. * @return The object that was removed */ public synchronized Object remove(int index) { makeDirty(); if (useCache) { loadFromStore(); } int size = (useCache ? delegate.size() : -1); Object delegateObject = (useCache ? delegate.remove(index) : null); Object backingObject = null; if (backingStore != null) { if (SCOUtils.useQueuedUpdate(queued, ownerOP)) { backingObject = delegateObject; ownerOP .getExecutionContext() .addOperationToQueue(new ListRemoveAtOperation(ownerOP, backingStore, index)); } else { try { backingObject = backingStore.remove(ownerOP, index, size); } catch (NucleusDataStoreException dse) { NucleusLogger.PERSISTENCE.warn( Localiser.msg("023013", "remove", ownerMmd.getName(), dse)); backingObject = null; } } } if (ownerOP != null && !ownerOP.getExecutionContext().getTransaction().isActive()) { ownerOP.getExecutionContext().processNontransactionalUpdate(); } return (backingStore != null ? backingObject : delegateObject); }
/** Method to delete the object from the datastore. */ protected void internalDeletePersistent() { if (isDeleting()) { throw new NucleusUserException(Localiser.msg("026008")); } activity = ActivityState.DELETING; try { if (dirty) { clearDirtyFlags(); // Clear the PM's knowledge of our being dirty. This calls flush() which does nothing myEC.flushInternal(false); } myEC.getNucleusContext(); if (!isEmbedded()) { // Nothing to delete if embedded getStoreManager().getPersistenceHandler().deleteObject(this); } preDeleteLoadedFields = null; } finally { activity = ActivityState.NONE; } }
public void executeClear(ObjectProvider ownerOP) { String clearStmt = getClearStmt(); try { ExecutionContext ec = ownerOP.getExecutionContext(); ManagedConnection mconn = storeMgr.getConnection(ec); SQLController sqlControl = storeMgr.getSQLController(); try { PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, clearStmt, false); try { int jdbcPosition = 1; jdbcPosition = BackingStoreHelper.populateOwnerInStatement(ownerOP, ec, ps, jdbcPosition, this); if (getRelationDiscriminatorMapping() != null) { BackingStoreHelper.populateRelationDiscriminatorInStatement(ec, ps, jdbcPosition, this); } sqlControl.executeStatementUpdate(ec, mconn, clearStmt, ps, true); } finally { sqlControl.closeStatement(mconn, ps); } } finally { mconn.release(); } } catch (SQLException e) { throw new NucleusDataStoreException(Localiser.msg("056013", clearStmt), e); } }
public MemberAnnotationHandler getHandlerForMemberAnnotation(String annotationName) { if (memberAnnotationHandlerAnnotations == null || !memberAnnotationHandlerAnnotations.contains(annotationName)) { return null; } MemberAnnotationHandler handler = memberAnnotationHandlers.get(annotationName); if (handler == null) { // Try to create this MemberAnnotationHandler try { PluginManager pluginMgr = metadataMgr.getNucleusContext().getPluginManager(); handler = (MemberAnnotationHandler) pluginMgr.createExecutableExtension( "org.datanucleus.member_annotation_handler", "annotation-class", annotationName, "handler", null, null); memberAnnotationHandlers.put(annotationName, handler); } catch (Exception e) { NucleusLogger.METADATA.warn( Localiser.msg("MetaData.MemberAnnotationHandlerNotFound", annotationName)); return null; } } return handler; }
/* (non-Javadoc) * @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List) */ public SQLExpression getExpression(SQLExpression expr, List<SQLExpression> args) { if (args == null || args.size() == 0 || args.size() > 1) { throw new NucleusException(Localiser.msg("060016", "containsValue", "MapExpression", 1)); } MapExpression mapExpr = (MapExpression) expr; SQLExpression valExpr = args.get(0); if (valExpr.isParameter()) { // Value is a parameter so make sure its type is set AbstractMemberMetaData mmd = mapExpr.getJavaTypeMapping().getMemberMetaData(); if (mmd != null && mmd.getMap() != null) { Class valCls = stmt.getQueryGenerator() .getClassLoaderResolver() .classForName(mmd.getMap().getValueType()); stmt.getQueryGenerator().bindParameter(valExpr.getParameterName(), valCls); } } if (mapExpr instanceof MapLiteral) { MapLiteral lit = (MapLiteral) mapExpr; Map map = (Map) lit.getValue(); if (map == null || map.size() == 0) { return new BooleanLiteral(stmt, expr.getJavaTypeMapping(), Boolean.FALSE); } // TODO If valExpr is a parameter and mapExpr is derived from a parameter ? MapValueLiteral mapValueLiteral = lit.getValueLiteral(); BooleanExpression bExpr = null; List<SQLExpression> elementExprs = mapValueLiteral.getValueExpressions(); for (int i = 0; i < elementExprs.size(); i++) { if (bExpr == null) { bExpr = (elementExprs.get(i)).eq(valExpr); } else { bExpr = bExpr.ior((elementExprs.get(i)).eq(valExpr)); } } if (bExpr != null) { bExpr.encloseInParentheses(); } return bExpr; } if (stmt.getQueryGenerator().getCompilationComponent() == CompilationComponent.FILTER) { boolean needsSubquery = getNeedsSubquery(); // TODO Check if *this* "containsValue" is negated, not any of them (and remove above check) if (needsSubquery) { NucleusLogger.QUERY.debug( "map.containsValue on " + mapExpr + "(" + valExpr + ") using SUBQUERY"); return containsAsSubquery(mapExpr, valExpr); } NucleusLogger.QUERY.debug( "map.containsValue on " + mapExpr + "(" + valExpr + ") using INNERJOIN"); return containsAsInnerJoin(mapExpr, valExpr); } return containsAsSubquery(mapExpr, valExpr); }
/** * Method to execute a PreparedStatement query, and return the ResultSet. Prints logging * information about timings. * * @param conn The connection (required since the one on PreparedStatement is not always the same * so we can't use it) * @param stmt The statement text * @param ps The Prepared Statement * @return The ResultSet from the query * @throws SQLException Thrown if an error occurs */ public ResultSet executeStatementQuery( ExecutionContext ec, ManagedConnection conn, String stmt, PreparedStatement ps) throws SQLException { if (supportsBatching) { ConnectionStatementState state = getConnectionStatementState(conn); if (state != null) { if (state.processable) { // Current batch statement is processable now so lets just process it before processing // our query processConnectionStatement(conn); } else { // Current wait statement is not processable now so leave it in wait state if (NucleusLogger.DATASTORE_RETRIEVE.isDebugEnabled()) { NucleusLogger.DATASTORE_RETRIEVE.debug(LOCALISER.msg("052106", state.stmtText, stmt)); } } } } // Execute this query long startTime = System.currentTimeMillis(); if (NucleusLogger.DATASTORE_NATIVE.isDebugEnabled()) { if (ps instanceof ParamLoggingPreparedStatement) { NucleusLogger.DATASTORE_NATIVE.debug( ((ParamLoggingPreparedStatement) ps).getStatementWithParamsReplaced()); } else { NucleusLogger.DATASTORE_NATIVE.debug(stmt); } } ResultSet rs = ps.executeQuery(); if (ec != null && ec.getStatistics() != null) { // Add to statistics ec.getStatistics().incrementNumReads(); } ps.clearBatch(); if (NucleusLogger.DATASTORE_RETRIEVE.isDebugEnabled()) { NucleusLogger.DATASTORE_RETRIEVE.debug( LOCALISER.msg("045000", (System.currentTimeMillis() - startTime))); } return rs; }
/** * Clear the association from owner to all elements. Provides cascade-delete when the elements * being deleted are PC types. * * @param ownerOP ObjectProvider for the container. */ public void clear(ObjectProvider ownerOP) { Collection dependentElements = null; CollectionMetaData collmd = ownerMemberMetaData.getCollection(); boolean dependent = collmd.isDependentElement(); if (ownerMemberMetaData.isCascadeRemoveOrphans()) { dependent = true; } if (dependent && !collmd.isEmbeddedElement() && !collmd.isSerializedElement()) { // Retain the dependent elements that need deleting after clearing dependentElements = new HashSet(); Iterator iter = iterator(ownerOP); while (iter.hasNext()) { dependentElements.add(iter.next()); } } String clearStmt = getClearStmt(); try { ExecutionContext ec = ownerOP.getExecutionContext(); ManagedConnection mconn = storeMgr.getConnection(ec); SQLController sqlControl = storeMgr.getSQLController(); try { PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, clearStmt, false); try { int jdbcPosition = 1; jdbcPosition = BackingStoreHelper.populateOwnerInStatement(ownerOP, ec, ps, jdbcPosition, this); if (relationDiscriminatorMapping != null) { BackingStoreHelper.populateRelationDiscriminatorInStatement(ec, ps, jdbcPosition, this); } sqlControl.executeStatementUpdate(ec, mconn, clearStmt, ps, true); } finally { sqlControl.closeStatement(mconn, ps); } } finally { mconn.release(); } } catch (SQLException e) { throw new NucleusDataStoreException(Localiser.msg("056013", clearStmt), e); } // Cascade-delete if (dependentElements != null && dependentElements.size() > 0) { Iterator iter = dependentElements.iterator(); while (iter.hasNext()) { Object obj = iter.next(); if (ownerOP.getExecutionContext().getApiAdapter().isDeleted(obj)) { // Element is tagged for deletion so will be deleted at flush(), and we dont need it // immediately } else { ownerOP.getExecutionContext().deleteObjectInternal(obj); } } } }
/** * Convenience method to create a new PreparedStatement for a query. * * @param conn The Connection to use for the statement * @param stmtText Statement text * @param resultSetType Type of result set * @param resultSetConcurrency Concurrency for the result set * @return The PreparedStatement * @throws SQLException thrown if an error occurs creating the statement */ public PreparedStatement getStatementForQuery( ManagedConnection conn, String stmtText, String resultSetType, String resultSetConcurrency) throws SQLException { Connection c = (Connection) conn.getConnection(); if (supportsBatching) { // Check for a waiting batched statement that is ready for processing ConnectionStatementState state = getConnectionStatementState(conn); if (state != null && state.processable) { // Process the batch statement before returning our new query statement processConnectionStatement(conn); } } // Create a new PreparedStatement for this query PreparedStatement ps = null; if (resultSetType != null || resultSetConcurrency != null) { int rsTypeValue = ResultSet.TYPE_FORWARD_ONLY; if (resultSetType != null) { if (resultSetType.equals("scroll-sensitive")) { rsTypeValue = ResultSet.TYPE_SCROLL_SENSITIVE; } else if (resultSetType.equals("scroll-insensitive")) { rsTypeValue = ResultSet.TYPE_SCROLL_INSENSITIVE; } } int rsConcurrencyValue = ResultSet.CONCUR_READ_ONLY; if (resultSetConcurrency != null && resultSetConcurrency.equals("updateable")) { rsConcurrencyValue = ResultSet.CONCUR_UPDATABLE; } ps = c.prepareStatement(stmtText, rsTypeValue, rsConcurrencyValue); ps .clearBatch(); // In case using statement caching and given one with batched statements // left hanging (C3P0) } else { ps = c.prepareStatement(stmtText); ps .clearBatch(); // In case using statement caching and given one with batched statements // left hanging (C3P0) } if (queryTimeout > 0) { // Apply any query timeout ps.setQueryTimeout(queryTimeout / 1000); // queryTimeout is in milliseconds } if (NucleusLogger.DATASTORE.isDebugEnabled()) { NucleusLogger.DATASTORE.debug(LOCALISER.msg("052110", StringUtils.toJVMIDString(ps))); } if (!jdbcStatements) { // Wrap with our parameter logger ps = new ParamLoggingPreparedStatement(ps, stmtText); ((ParamLoggingPreparedStatement) ps).setParamsInAngleBrackets(paramValuesInBrackets); } return ps; }
/** * This method requires synchronization so that we don't end up registering the same property more * than once. */ @Override protected synchronized StoreData newStoreData(ClassMetaData cmd, ClassLoaderResolver clr) { InheritanceStrategy strat = cmd.getInheritanceMetaData().getStrategy(); // The overarching rule for supported inheritance strategies is that we // don't split the state of an object across multiple entities. // TODO This is all nonsense. This datastore only allows "COMPLETE_TABLE" really so ignore the // inheritance // and remove the need for DatastoreClass if (strat == InheritanceStrategy.SUBCLASS_TABLE) { // Table mapped into the table(s) of subclass(es) // Just add the SchemaData entry with no table - managed by subclass return buildStoreDataWithNoTable(cmd); } else if (strat == InheritanceStrategy.COMPLETE_TABLE) { if (cmd.isAbstract()) { // Abstract class with "complete-table" so gets no table return buildStoreDataWithNoTable(cmd); } return buildStoreData(cmd, clr); } else if (strat == InheritanceStrategy.NEW_TABLE && (cmd.getSuperAbstractClassMetaData() == null || cmd.getSuperAbstractClassMetaData().getInheritanceMetaData().getStrategy() == InheritanceStrategy.SUBCLASS_TABLE)) { // New Table means you store your fields and your fields only (no fields from superclasses). // This only ok if you don't have a persistent superclass or your persistent superclass has // delegated responsibility for storing its fields to you. return buildStoreData(cmd, clr); } else if (MetaDataUtils.isNewOrSuperclassTableInheritanceStrategy(cmd)) { // Table mapped into table of superclass // Find the superclass - should have been created first AbstractClassMetaData[] managingCmds = getClassesManagingTableForClass(cmd, clr); DatastoreTable superTable; if (managingCmds != null && managingCmds.length == 1) { MappedStoreData superData = (MappedStoreData) storeDataMgr.get(managingCmds[0].getFullClassName()); if (superData != null) { // Specify the table if it already exists superTable = (DatastoreTable) superData.getDatastoreContainerObject(); return buildStoreDataWithTable(cmd, superTable); } } } // TODO Don't do this. GAE basically supports "complete-table" always so we should just ignore // any // inheritance metadata that implies otherwise. boolean jpa = getApiAdapter().getName().equalsIgnoreCase("JPA"); String unsupportedMsg = GAE_LOCALISER.msg( jpa ? "AppEngine.BadInheritance.JPA" : "AppEngine.BadInheritance.JDO", cmd.getInheritanceMetaData().getStrategy().toString(), cmd.getFullClassName(), getApiAdapter().getName()); throw new UnsupportedInheritanceStrategyException(unsupportedMsg); }
public void registerExtensions() { if (extensionPoints.length > 0) { return; } List registeringExtensions = new ArrayList(); BundleContext ctx = FrameworkUtil.getBundle(this.getClass()).getBundleContext(); // parse the plugin files DocumentBuilder docBuilder = OSGiBundleParser.getDocumentBuilder(); org.osgi.framework.Bundle[] osgiBundles = ctx.getBundles(); for (org.osgi.framework.Bundle osgiBundle : osgiBundles) { URL pluginURL = osgiBundle.getEntry("plugin.xml"); if (pluginURL == null) { continue; } Bundle bundle = registerBundle(osgiBundle); if (bundle == null) { // No MANIFEST.MF for this plugin.xml so ignore it continue; } List[] elements = OSGiBundleParser.parsePluginElements(docBuilder, this, pluginURL, bundle, osgiBundle); registerExtensionPointsForPluginInternal(elements[0], false); registeringExtensions.addAll(elements[1]); } extensionPoints = extensionPointsByUniqueId .values() .toArray(new ExtensionPoint[extensionPointsByUniqueId.values().size()]); // Register the extensions now that we have the extension-points all loaded for (int i = 0; i < registeringExtensions.size(); i++) { Extension extension = (Extension) registeringExtensions.get(i); ExtensionPoint exPoint = getExtensionPoint(extension.getExtensionPointId()); if (exPoint == null) { if (extension.getPlugin() != null && extension.getPlugin().getSymbolicName() != null && extension.getPlugin().getSymbolicName().startsWith(DATANUCLEUS_PKG)) { NucleusLogger.GENERAL.warn( Localiser.msg( "024002", extension.getExtensionPointId(), extension.getPlugin().getSymbolicName(), extension.getPlugin().getManifestLocation())); } } else { extension.setExtensionPoint(exPoint); exPoint.addExtension(extension); } } }
/* (non-Javadoc) * @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List) */ public SQLExpression getExpression(SQLExpression expr, List<SQLExpression> args) { if (expr == null) { if (args != null && args.size() > 0) { throw new NucleusException("COUNTSTAR takes no argument"); } return new AggregateNumericExpression(stmt, getMappingForClass(long.class), "COUNT(*)"); } throw new NucleusException(Localiser.msg("060002", "COUNT", expr)); }
/** * Constructor. * * @param tableName The Table SQL identifier * @param mmd Member meta data for the owner field/property * @param storeMgr Manager for the datastore. */ protected JoinTable( DatastoreIdentifier tableName, AbstractMemberMetaData mmd, RDBMSStoreManager storeMgr) { super(tableName, storeMgr); this.mmd = mmd; this.ownerType = mmd.getClassName(true); if (mmd.getPersistenceModifier() == FieldPersistenceModifier.NONE) { throw new NucleusException(Localiser.msg("057006", mmd.getName())).setFatal(); } }
/* * (non-Javadoc) * @see * org.datanucleus.store.rdbms.mapping.datastore.AbstractDatastoreMapping#setObject(java.sql.PreparedStatement, int, java.lang.Object) */ @Override public void setObject(PreparedStatement ps, int param, Object value) { try { if (value == null) { ps.setNull(param, Types.LONGVARBINARY); } else if (value instanceof File) { File file = (File) value; ps.setBinaryStream(param, new FileInputStream(file), (int) file.length()); } else { // TODO Support other types throw new NucleusDataStoreException( "setObject unsupported for java type " + value.getClass().getName()); } } catch (SQLException e) { throw new NucleusDataStoreException( Localiser.msg("055001", "Object", "" + value, column, e.getMessage()), e); } catch (IOException e) { throw new NucleusDataStoreException( Localiser.msg("055001", "Object", "" + value, column, e.getMessage()), e); } }
/** * Method to remove a collection of elements from the List. * * @param elements Collection of elements to remove * @return Whether it was successful. */ public boolean removeAll(Collection elements) { makeDirty(); if (useCache) { loadFromStore(); } int size = (useCache ? delegate.size() : -1); Collection contained = null; if (backingStore != null && SCOUtils.useQueuedUpdate(queued, ownerOP)) { // Check which are contained before updating the delegate contained = new java.util.HashSet(); for (Object elem : elements) { if (contains(elem)) { contained.add(elem); } } } boolean delegateSuccess = delegate.removeAll(elements); if (backingStore != null) { boolean backingSuccess = true; if (SCOUtils.useQueuedUpdate(queued, ownerOP)) { backingSuccess = false; for (Object element : contained) { backingSuccess = true; ownerOP .getExecutionContext() .addOperationToQueue( new CollectionRemoveOperation(ownerOP, backingStore, element, true)); } } else { try { backingSuccess = backingStore.removeAll(ownerOP, elements, size); } catch (NucleusDataStoreException dse) { NucleusLogger.PERSISTENCE.warn( Localiser.msg("023013", "removeAll", ownerMmd.getName(), dse)); backingSuccess = false; } } if (ownerOP != null && !ownerOP.getExecutionContext().getTransaction().isActive()) { ownerOP.getExecutionContext().processNontransactionalUpdate(); } return backingSuccess; } if (ownerOP != null && !ownerOP.getExecutionContext().getTransaction().isActive()) { ownerOP.getExecutionContext().processNontransactionalUpdate(); } return delegateSuccess; }
/** Method to initialise the SCO for use. */ public void initialise() { initialiseDelegate(); if (NucleusLogger.PERSISTENCE.isDebugEnabled()) { NucleusLogger.PERSISTENCE.debug( LOCALISER.msg( "023003", ownerOP.getObjectAsPrintable(), ownerMmd.getName(), "" + size(), SCOUtils.getSCOWrapperOptionsMessage(true, false, false, false))); } }
/** Evaluator for the method "{listExpr}.get(idxExpr)". */ public class ListGetMethodEvaluator implements InvocationEvaluator { /** Localisation utility for output messages */ protected static final Localiser LOCALISER = Localiser.getInstance( "org.datanucleus.Localisation", org.datanucleus.ClassConstants.NUCLEUS_CONTEXT_LOADER); /* (non-Javadoc) * @see org.datanucleus.query.evaluator.memory.InvocationEvaluator#evaluate(org.datanucleus.query.expression.InvokeExpression, org.datanucleus.query.evaluator.memory.InMemoryExpressionEvaluator) */ public Object evaluate( InvokeExpression expr, Object invokedValue, InMemoryExpressionEvaluator eval) { String method = expr.getOperation(); if (invokedValue == null) { return null; } if (!(invokedValue instanceof List)) { throw new NucleusException( LOCALISER.msg("021011", method, invokedValue.getClass().getName())); } Object param = expr.getArguments().get(0); Object paramValue = null; if (param instanceof Literal) { paramValue = ((Literal) param).getLiteral(); } else if (param instanceof PrimaryExpression) { PrimaryExpression primExpr = (PrimaryExpression) param; paramValue = eval.getValueForPrimaryExpression(primExpr); } else if (param instanceof ParameterExpression) { ParameterExpression paramExpr = (ParameterExpression) param; paramValue = QueryUtils.getValueForParameterExpression(eval.getParameterValues(), paramExpr); } else if (param instanceof VariableExpression) { VariableExpression varExpr = (VariableExpression) param; try { paramValue = eval.getValueForVariableExpression(varExpr); } catch (VariableNotSetException vnse) { // Throw an exception with the possible values of elements throw new VariableNotSetException(varExpr, ((List) invokedValue).toArray()); } } else { throw new NucleusException( "Dont currently support use of get(" + param.getClass().getName() + ")"); } int paramInt; if (paramValue instanceof Number) { paramInt = ((Number) paramValue).intValue(); } else { throw new NucleusException("List.get() should take in an integer but is " + paramValue); } return ((List) invokedValue).get(paramInt); } }
/* (non-Javadoc) * @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List) */ public SQLExpression getExpression(SQLExpression expr, List<SQLExpression> args) { if (!expr.isParameter() && expr instanceof StringLiteral) { JavaTypeMapping m = exprFactory.getMappingForType(int.class, false); String val = (String) ((StringLiteral) expr).getValue(); return new IntegerLiteral(stmt, m, Integer.valueOf(val.length()), null); } else if (expr instanceof StringExpression || expr instanceof ParameterLiteral) { ArrayList funcArgs = new ArrayList(); funcArgs.add(expr); return new NumericExpression(stmt, getMappingForClass(int.class), "CHAR_LENGTH", funcArgs); } else { throw new NucleusException(Localiser.msg("060001", "length", expr)); } }
/** * Convenience method to apply the user specification of <primary-key> columns * * @param pkmd MetaData for the primary key */ protected void applyUserPrimaryKeySpecification(PrimaryKeyMetaData pkmd) { ColumnMetaData[] pkCols = pkmd.getColumnMetaData(); for (int i = 0; i < pkCols.length; i++) { String colName = pkCols[i].getName(); boolean found = false; for (int j = 0; j < ownerMapping.getNumberOfDatastoreMappings(); j++) { if (ownerMapping .getDatastoreMapping(j) .getColumn() .getIdentifier() .getName() .equals(colName)) { ownerMapping.getDatastoreMapping(j).getColumn().setPrimaryKey(); found = true; } } if (!found) { for (int j = 0; j < keyMapping.getNumberOfDatastoreMappings(); j++) { if (keyMapping .getDatastoreMapping(j) .getColumn() .getIdentifier() .getName() .equals(colName)) { keyMapping.getDatastoreMapping(j).getColumn().setPrimaryKey(); found = true; } } } if (!found) { for (int j = 0; j < valueMapping.getNumberOfDatastoreMappings(); j++) { if (valueMapping .getDatastoreMapping(j) .getColumn() .getIdentifier() .getName() .equals(colName)) { valueMapping.getDatastoreMapping(j).getColumn().setPrimaryKey(); found = true; } } } if (!found) { throw new NucleusUserException(Localiser.msg("057040", toString(), colName)); } } }
/** Method to load all elements from the "backing store" where appropriate. */ protected void loadFromStore() { if (backingStore != null && !isCacheLoaded) { if (NucleusLogger.PERSISTENCE.isDebugEnabled()) { NucleusLogger.PERSISTENCE.debug( Localiser.msg("023006", ownerOP.getObjectAsPrintable(), ownerMmd.getName())); } delegate.clear(); // Populate the delegate with the keys/values from the store SCOUtils.populateMapDelegateWithStoreData(delegate, backingStore, ownerOP); isCacheLoaded = true; } }
/** Method to load all elements from the "backing store" where appropriate. */ protected void loadFromStore() { if (backingStore != null && !isCacheLoaded) { if (NucleusLogger.PERSISTENCE.isDebugEnabled()) { NucleusLogger.PERSISTENCE.debug( Localiser.msg("023006", ownerOP.getObjectAsPrintable(), ownerMmd.getName())); } delegate.clear(); Iterator iter = backingStore.iterator(ownerOP); while (iter.hasNext()) { delegate.add(iter.next()); } isCacheLoaded = true; } }
/* (non-Javadoc) * @see org.datanucleus.query.evaluator.memory.InvocationEvaluator#evaluate(org.datanucleus.query.expression.InvokeExpression, org.datanucleus.query.evaluator.memory.InMemoryExpressionEvaluator) */ public Object evaluate( InvokeExpression expr, Object invokedValue, InMemoryExpressionEvaluator eval) { String method = expr.getOperation(); if (invokedValue == null) { return Boolean.FALSE; } if (!(invokedValue instanceof Date)) { throw new NucleusException( Localiser.msg("021011", method, invokedValue.getClass().getName())); } Calendar cal = Calendar.getInstance(); cal.setTime((Date) invokedValue); return Integer.valueOf(cal.get(Calendar.MONTH)); }
/** * Convenience method to retrieve field values from an L2 cached object if they are loaded in that * object. If the object is not in the L2 cache then just returns, and similarly if the required * fields aren't available. * * @param fieldNumbers Numbers of fields to load from the L2 cache * @return The fields that couldn't be loaded */ protected int[] loadFieldsFromLevel2Cache(int[] fieldNumbers) { // Only continue if there are fields, and not being deleted/flushed etc if (fieldNumbers == null || fieldNumbers.length == 0 || myEC.isFlushing() || myLC.isDeleted() || isDeleting() || getExecutionContext().getTransaction().isCommitting()) { return fieldNumbers; } // TODO Drop this check when we're confident that this doesn't affect some use-cases if (!myEC.getNucleusContext() .getConfiguration() .getBooleanProperty(PropertyNames.PROPERTY_CACHE_L2_LOADFIELDS, true)) { return fieldNumbers; } Level2Cache l2cache = myEC.getNucleusContext().getLevel2Cache(); if (l2cache != null && myEC.getNucleusContext().isClassCacheable(cmd)) { CachedPC<T> cachedPC = l2cache.get(myID); if (cachedPC != null) { int[] cacheFieldsToLoad = ClassUtils.getFlagsSetTo(cachedPC.getLoadedFields(), fieldNumbers, true); if (cacheFieldsToLoad != null && cacheFieldsToLoad.length > 0) { if (NucleusLogger.CACHE.isDebugEnabled()) { NucleusLogger.CACHE.debug( Localiser.msg( "026034", StringUtils.toJVMIDString(getObject()), myID, StringUtils.intArrayToString(cacheFieldsToLoad))); } L2CacheRetrieveFieldManager l2RetFM = new L2CacheRetrieveFieldManager(this, cachedPC); this.replaceFields(cacheFieldsToLoad, l2RetFM); int[] fieldsNotLoaded = l2RetFM.getFieldsNotLoaded(); if (fieldsNotLoaded != null) { for (int i = 0; i < fieldsNotLoaded.length; i++) { loadedFields[fieldsNotLoaded[i]] = false; } } } } } return ClassUtils.getFlagsSetTo(loadedFields, fieldNumbers, false); }