public PreparedStatementManagerImpl(JDBCStore store,
    Connection conn) 
{
            
        _store = store;
        _dict = store.getDBDictionary();
        _conn = conn;
}

Constructor. Supply connection.

 protected int executeUpdate(PreparedStatement stmnt,
    String sql,
    RowImpl row) throws SQLException 
{
        return stmnt.executeUpdate();
}

This method is to provide override for non-JDBC or JDBC-like implementation of executing update.

 public  void flush() 
{

}

 public  void flush(RowImpl row) 
{
        try {
            flushInternal(row);
        } catch (SQLException se) {
            _exceptions.add(SQLExceptions.getStore(se, _dict));
        } catch (OpenJPAException ke) {
            _exceptions.add(ke);
        }
}

 protected  void flushAndUpdate(RowImpl row) throws SQLException 
{
        // prepare statement
        String sql = row.getSQL(_dict);
        PreparedStatement stmnt = prepareStatement(sql);
        // setup parameters and execute statement
        if (stmnt != null)
            row.flush(stmnt, _dict, _store);
        try {
            int count = executeUpdate(stmnt, sql, row);
            if (count != 1) {
                Object failed = row.getFailedObject();
                if (failed != null)
                    _exceptions.add(new OptimisticException(failed));
                else if (row.getAction() == Row.ACTION_INSERT)
                    throw new SQLException(_loc.get(
                        "update-failed-no-failed-obj", String.valueOf(count),
                        sql).getMessage());
            }
        } catch (SQLException se) {
            throw SQLExceptions.getStore(se, row.getFailedObject(), _dict);
        } finally {
            if (stmnt != null) {
                try {
                    stmnt.close();
                } catch (SQLException se) {
                }
            }
        }
}

Flush the given row immediately.

 protected  void flushInternal(RowImpl row) throws SQLException 
{
        // can't batch rows with auto-inc columns
        Column[] autoAssign = null;
        if (row.getAction() == Row.ACTION_INSERT)
            autoAssign = row.getTable().getAutoAssignedColumns();
        flushAndUpdate(row);
        // set auto assign values
        if (autoAssign != null && autoAssign.length  > 0
            && row.getPrimaryKey() != null) {
            OpenJPAStateManager sm = row.getPrimaryKey();
            ClassMapping mapping = (ClassMapping) sm.getMetaData();
            Object val;
            for (int i = 0; i <  autoAssign.length; i++) {
                val = _dict.getGeneratedKey(autoAssign[i], _conn);
                mapping.assertJoinable(autoAssign[i]).setAutoAssignedValue(sm,
                    _store, autoAssign[i], val);
            }
            sm.setObjectId(
                ApplicationIds.create(sm.getPersistenceCapable(), mapping));
        }
}

Flush the given row.

 public Collection getExceptions() 
{
        return _exceptions;
}

 protected PreparedStatement prepareStatement(String sql) throws SQLException 
{
        return _conn.prepareStatement(sql);
}

This method is to provide override for non-JDBC or JDBC-like implementation of preparing statement.