Examples of org.jpox.ManagedConnection

org.jpox.ManagedConnection
Wrapper for a connection to the datastore, allowing management. @version $Revision: 1.6 $

                stmt[useUpdateLock ? 1 : 0] = fetchStatement.toString(useUpdateLock);
            }


            try
            {
                ManagedConnection mconn = storeMgr.getConnection(om);
                SQLController sqlControl = storeMgr.getSQLController();


                try
                {
                    PreparedStatement ps = sqlControl.getStatementForQuery(mconn, stmt[useUpdateLock ? 1 : 0]);


                    try
                    {
                        // Provide the primary key field(s)
                        if (sm.getInternalObjectId() instanceof OID)
                        {
                            table.getDataStoreObjectIdMapping().setObject(om, ps, 
                                mappingStatementIndex.getDatastoreId().getParameterIndex(), sm.getInternalObjectId());
                        }
                        else
                        {
                            sm.provideFields(consumer.getPrimaryKeyFieldsToBeProvided(), 
                                new ParameterSetter(sm, ps, mappingStatementIndex.getFields(), false));
                        }


                        ResultSet rs = sqlControl.executeStatementQuery(mconn, stmt[useUpdateLock ? 1 : 0], ps);
                        try
                        {
                            if (!rs.next())
                            {
                                JPOXLogger.DATASTORE_RETRIEVE.warn(LOCALISER.msg("050018",
                                    sm.getInternalObjectId()));
                                throw new JPOXObjectNotFoundException("No such database row", sm.getInternalObjectId());
                            }
                            sm.replaceFields(consumer.getNumbersOfFieldsToBeFetched(), 
                                new ResultSetGetter(sm, rs, mappingStatementIndex.getFields()));


                            if (sm.getTransactionalVersion(sm.getObject()) == null)
                            {
                                // Object has no version set so update it from this fetch
                                Object datastoreVersion = null;
                                if (fetchingSurrogateVersion)
                                {
                                    // Surrogate version column - get from the result set using the version mapping
                                    datastoreVersion = table.getVersionMapping(true).getObject(om, rs,  
                                        mappingStatementIndex.getVersion().getExpressionIndex());
                                }
                                else if (versionFieldName != null)
                                {
                                    // Version field - already populated in the field in the object
                                    AbstractClassMetaData cmd = (AbstractClassMetaData)versionMetaData.getParent();
                                    datastoreVersion = sm.provideField(cmd.getAbsolutePositionOfMember(versionFieldName));
                                }
                                sm.setVersion(datastoreVersion);
                            }
                        }
                        finally
                        {
                            rs.close();
                        }
                    }
                    finally
                    {
                        sqlControl.closeStatement(mconn, ps);
                    }
                }
                finally
                {
                    mconn.release();
                }
            }
            catch (SQLException e)
            {
                String msg = LOCALISER.msg("052219",

View Full Code Here

        boolean keyExists = false;
        ObjectManager om = sm.getObjectManager();


        try
        {
            ManagedConnection mconn = storeMgr.getConnection(om);
            SQLController sqlControl = storeMgr.getSQLController();


            try
            {
                PreparedStatement ps = sqlControl.getStatementForQuery(mconn, findKeyStmt);


                try
                {
                    int jdbcPosition = 1;
                    jdbcPosition = populateOwnerInStatement(sm, om, ps, jdbcPosition);
                    jdbcPosition = populateElementInStatement(om, ps, element, jdbcPosition);


                    ResultSet rs = sqlControl.executeStatementQuery(mconn, findKeyStmt, ps);
                    try
                    {
                        if (rs.next())
                        {
                            key = keyMapping.getObject(om, rs, Mappings.getParametersIndex(1,keyMapping));
                            keyExists = true;
                        }


                        SQLWarnings.log(rs);
                    }
                    finally
                    {
                        rs.close();
                    }
                }
                finally
                {
                    sqlControl.closeStatement(mconn, ps);
                }
            }
            finally
            {
                mconn.release();
            }
        }
        catch (SQLException e)
        {
            throw new JPOXDataStoreException("Request failed to check if set contains an element: " + findKeyStmt, e);

View Full Code Here


        String clearStmt = getClearStmt();
        try
        {
            ObjectManager om = ownerSM.getObjectManager();
            ManagedConnection mconn = storeMgr.getConnection(om);
            SQLController sqlControl = storeMgr.getSQLController();
            try
            {
                PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, clearStmt, false);
                try
                {
                    int jdbcPosition = 1;
                    jdbcPosition = populateOwnerInStatement(ownerSM, om, ps, jdbcPosition);
                    if (relationDiscriminatorMapping != null)
                    {
                        jdbcPosition = populateRelationDiscriminatorInStatement(om, ps, jdbcPosition);
                    }


                    sqlControl.executeStatementUpdate(mconn, clearStmt, ps, true);
                }
                finally
                {
                    sqlControl.closeStatement(mconn, ps);
                }
            }
            finally
            {
                mconn.release();
            }
        }
        catch (SQLException e)
        {
            throw new JPOXDataStoreException(LOCALISER.msg("056013", clearStmt), e);

View Full Code Here

        {
            QueryResult qr = null;
            try
            {
                RDBMSManager storeMgr = (RDBMSManager)om.getStoreManager();
                ManagedConnection mconn = storeMgr.getConnection(om);
                SQLController sqlControl = storeMgr.getSQLController();


                try
                {
                    PreparedStatement ps = getStatement(mconn, compiledSQL);
                    try
                    {
                        // Set the values of any parameters
                        if (parameters != null)
                        {
                            for (int i=0;i<parameters.size();i++)
                            {
                                Object obj = parameters.get(new Integer(i+1));
                                ps.setObject((i+1), obj);
                            }
                        }


                        // Apply any user-specified constraints over timeouts and ResultSet
                        prepareStatementForExecution(ps);


                        // Execute the query
                        ResultSet rs = sqlControl.executeStatementQuery(mconn, compiledSQL, ps);
                        try
                        {
                            // Generate a ResultObjectFactory
                            if (resultMetaData != null)
                            {
                                // Each row of the ResultSet is defined by MetaData
                                rof = new ResultMetaDataROF(resultMetaData);
                            }
                            else if (resultClass != null || candidateClass == null)
                            {
                                // Each row of the ResultSet is either an instance of resultClass, or Object[]
                                rof = getResultObjectFactoryForNoCandidateClass(rs, resultClass);
                            }
                            else
                            {
                                // Each row of the ResultSet is an instance of the candidate class
                                rof = getResultObjectFactoryForCandidateClass(rs);
                            }


                            // Return the associated type of results depending on whether scrollable or not
                            if (getResultSetType().equals("scroll-insensitive") ||
                                getResultSetType().equals("scroll-sensitive"))
                            {
                                qr = new ScrollableQueryResult(null, query, rof, rs, null);
                            }
                            else
                            {
                                qr = new ForwardQueryResult(null, query, rof, rs, null);
                            }


                            final QueryResult qr1 = qr;
                            final ManagedConnection mconn1 = mconn;
                            mconn.addListener(new ManagedConnectionResourceListener()
                            {
                                public void managedConnectionFlushed()
                                {
                                    qr1.disconnect();                        
                                }


                                public void managedConnectionPreClose(){}
                                public void managedConnectionPostClose(){}
                                public void resourcePostClose()
                                {
                                    mconn1.removeListener(this);
                                }
                            });                            
                        }
                        finally
                        {

View Full Code Here

        boolean batched = allowsBatching() && length > 1;


        try
        {
            ObjectManager om = ownerSM.getObjectManager();
            ManagedConnection mconn = storeMgr.getConnection(om);
            SQLController sqlControl = storeMgr.getSQLController();
            sqlControl.processStatementsForConnection(mconn); // Process all waiting batched statements before we start our work


            try
            {
                // Loop through all elements to be added
                Object element = null;
                for (int i=0;i<length;i++)
                {
                    element = Array.get(array, i);


                    try
                    {
                        // Add the row to the join table
                        int[] rc = internalAdd(ownerSM, element, mconn, batched, i, (i == length-1));
                        if (rc != null)
                        {
                            for (int j=0;j<rc.length;j++)
                            {
                                if (rc[j] > 0)
                                {
                                    // At least one record was inserted
                                    modified = true;
                                }
                            }
                        }
                    }
                    catch (SQLException sqle)
                    {
                        sqle.printStackTrace();
                        exceptions.add(sqle);
                        JPOXLogger.DATASTORE.error(sqle);
                    }
                }
            }
            finally
            {
                mconn.release();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();

View Full Code Here

        boolean modified = false;


        try
        {
            ObjectManager om = sm.getObjectManager();
            ManagedConnection mconn = storeMgr.getConnection(om);


            try
            {
                // Add a row to the join table
                int[] returnCode = internalAdd(sm, element, mconn, false, position, true);
                if (returnCode[0] > 0)
                {
                    modified = true;
                }
            }
            finally
            {
                mconn.release();
            }
        }
        catch (SQLException e)
        {
            throw new JPOXDataStoreException(LOCALISER.msg("056009", getAddStmt()), e);

View Full Code Here

        }


        Iterator iter;
        try
        {
            ManagedConnection mconn = storeMgr.getConnection(om);
            SQLController sqlControl = storeMgr.getSQLController();
            try
            {
                PreparedStatement ps = storeMgr.getStatementForQuery(stmt, om, mconn, useUpdateLock, null, null);
                try
                {
                    ResultSet rs = sqlControl.executeStatementQuery(mconn, statement, ps);
                    try
                    {
                        iter = new ArrayStoreIterator(ownerSM, rs, rof);
                    }
                    finally
                    {
                        rs.close();
                    }
                }
                finally
                {
                    sqlControl.closeStatement(mconn, ps);
                }
            }
            finally
            {
                mconn.release();
            }
        }
        catch (SQLException e)
        {
            throw new JPOXDataStoreException(LOCALISER.msg("056006", statement), e);

View Full Code Here

        }


        // Process the delete of this object
        try
        {
            ManagedConnection mconn = storeMgr.getConnection(om);
            SQLController sqlControl = storeMgr.getSQLController();


            try
            {
                // Perform the delete
                boolean batch = true;
                if (optimisticChecks || !om.getTransaction().isActive())
                {
                    // Turn OFF batching if doing optimistic checks (since we need the result of the delete)
                    // or if using nontransactional writes (since we want it sending to the datastore now)
                    batch = false;
                }
                PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, stmt, batch);
                try
                {
                    // provide primary key field(s)
                    if (cmd.getIdentityType() == IdentityType.DATASTORE)
                    {
                        table.getDataStoreObjectIdMapping().setObject(om, ps,
                            mappingStatementIndex.getDatastoreId().getParameterIndex(), sm.getInternalObjectId());
                    }
                    else if (cmd.getIdentityType() == IdentityType.APPLICATION)
                    {
                        sm.provideFields(pkFieldNumbers, new ParameterSetter(sm, ps, 
                            mappingStatementIndex.getPrimaryKeys(),true));
                    }


                    if (optimisticChecks)
                    {
                        // WHERE clause - current version discriminator
                        JavaTypeMapping verMapping = mappingStatementIndex.getVersion2().getMapping();
                        Object currentVersion = sm.getTransactionalVersion(sm.getObject());
                        if (currentVersion == null)
                        {
                            // Somehow the version is not set on this object (not read in ?) so report the bug
                            String msg = LOCALISER.msg("052202", 
                                sm.getInternalObjectId(), table);
                            JPOXLogger.PERSISTENCE.error(msg);
                            throw new JPOXException(msg);
                        }
                        verMapping.setObject(om, ps,
                            mappingStatementIndex.getVersion2().getParameterIndex(), currentVersion);
                    }


                    int[] rcs = sqlControl.executeStatementUpdate(mconn, stmt, ps, !batch);
                    if (optimisticChecks && rcs[0] == 0)
                    {
                        // No object deleted so either object disappeared or failed optimistic version checks
                        String msg = LOCALISER.msg("052203", 
                            StringUtils.toJVMIDString(sm.getObject()), sm.getInternalObjectId(), 
                            "" + sm.getTransactionalVersion(sm.getObject()));
                        JPOXLogger.DATASTORE.error(msg);
                        throw new JPOXOptimisticException(msg, sm.getObject());
                    }
                }
                finally
                {
                    sqlControl.closeStatement(mconn, ps);
                }
            }
            finally
            {
                mconn.release();
            }
        }
        catch (SQLException e)
        {
            String msg = LOCALISER.msg("052211",

View Full Code Here

                    clearLinkStmt.append("=?");
                }


                try
                {
                    ManagedConnection mconn = storeMgr.getConnection(om);
                    SQLController sqlControl = storeMgr.getSQLController();
                    try
                    {
                        // Null out the relationship to the object being deleted.
                        PreparedStatement ps = null;
                        try
                        {
                            ps = sqlControl.getStatementForUpdate(mconn, clearLinkStmt.toString(), false);
                            refMapping.setObject(om, ps, Mappings.getParametersIndex(1, refMapping), sm.getObject());


                            sqlControl.executeStatementUpdate(mconn, clearLinkStmt.toString(), ps, true);
                        }
                        finally
                        {
                            if (ps != null)
                            {
                                sqlControl.closeStatement(mconn, ps);
                            }
                        }
                    }
                    finally
                    {
                        mconn.release();
                    }
                }
                catch (Exception e)
                {
                    e.printStackTrace();

View Full Code Here

        boolean retval;
        ObjectManager om = sm.getObjectManager();
        String updateFkStmt = getUpdateFkStmt();
        try
        {
            ManagedConnection mconn = storeMgr.getConnection(om);
            SQLController sqlControl = storeMgr.getSQLController();
            try
            {
                PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, updateFkStmt, false);
                try
                {
                    int jdbcPosition = 1;
                    if (elementInfo.length > 1)
                    {
                        DatastoreClass table = storeMgr.getDatastoreClass(element.getClass().getName(), clr);
                        if (table != null)
                        {
                            ps.setString(jdbcPosition++, table.toString());
                        }
                        else
                        {
                            JPOXLogger.PERSISTENCE.info(">> InverseArrayStore.updateElementFK : need to set table in statement but dont know table where to store " + element);
                        }
                    }
                    if (owner == null)
                    {
                        ownerMapping.setObject(om, ps, Mappings.getParametersIndex(jdbcPosition, ownerMapping), null);
                        jdbcPosition += ownerMapping.getNumberOfDatastoreFields();
                    }
                    else
                    {
                        jdbcPosition = populateOwnerInStatement(sm, om, ps, jdbcPosition);
                    }
                    jdbcPosition = populateOrderInStatement(om, ps, index, jdbcPosition);
                    if (relationDiscriminatorMapping != null)
                    {
                        jdbcPosition = populateRelationDiscriminatorInStatement(om, ps, jdbcPosition);
                    }
                    jdbcPosition = populateElementInStatement(om, ps, element, jdbcPosition);


                    sqlControl.executeStatementUpdate(mconn, updateFkStmt, ps, true);
                    retval = true;
                }
                finally
                {
                    sqlControl.closeStatement(mconn, ps);
                }
            }
            finally
            {
                mconn.release();
            }
        }
        catch (SQLException e)
        {
            throw new JPOXDataStoreException(LOCALISER.msg("056027", updateFkStmt),e);

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of org.jpox.ManagedConnection

org.jpox.store.rdbms.mapping.oracle.OracleBlobRDBMSMapping

org.jpox.store.rdbms.mapping.oracle.OracleClobRDBMSMapping

org.jpox.store.rdbms.query.JPOXSQLQuery$JPOXSQLQueryEvaluator

org.jpox.store.rdbms.query.SQLEvaluator

org.jpox.store.rdbms.query.SQLQuery

org.jpox.store.rdbms.query.SQLQuery$SQLQueryEvaluator

org.jpox.store.rdbms.RDBMSManager

org.jpox.store.rdbms.RDBMSStoreHelper

org.jpox.store.rdbms.request.DeleteRequest

org.jpox.store.rdbms.request.FetchRequest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.