Changeset 3459


Ignore:
Timestamp:
08/22/13 13:18:54 (11 years ago)
Author:
olhsha
Message:

making deleters safe in any DAO (except notebooks). that is before delete the resources if checked if it is mentioned in ANY of the joint tables where he is one of the columns. if "yes" then deleting does not happen. Earlier, it was checked only if it is used by a higher-lever resource (i.e. only one joint table was checked).

also, all resource_id row-mappers are moved to the base JdbcResource? class.

Location:
DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcAnnotationDao.java

    r3455 r3459  
    226226    };
    227227   
     228   /////////////////////////////
     229   
     230    private boolean annotationIsInUse(Number sourceID) {
     231        String sqlNotebooks = "SELECT " + notebook_id + " FROM " + notebooksAnnotationsTableName + " WHERE " + annotation_id + "= ? LIMIT 1";
     232        List<Number> resultNotebooks = getSimpleJdbcTemplate().query(sqlNotebooks, notebookIDRowMapper, sourceID);
     233        if (resultNotebooks.size() > 0) {
     234            return true;
     235        }
     236        String sqlSources = "SELECT " + source_id + " FROM " + annotationsSourcesTableName + " WHERE " + annotation_id + "= ? LIMIT 1";
     237        List<Number> resultSources = getSimpleJdbcTemplate().query(sqlSources, sourceIDRowMapper, sourceID);
     238        if (resultSources.size() > 0) {
     239            return true;
     240        }
     241        String sqlPermissions = "SELECT " + principal_id + " FROM " + permissionsTableName + " WHERE " + annotation_id + "= ? LIMIT 1";
     242        List<Number> resultPermissions = getSimpleJdbcTemplate().query(sqlPermissions, principalIDRowMapper, sourceID);
     243        if (resultPermissions.size() > 0) {
     244            return true;
     245        }
     246       
     247        return false;
     248    }
     249   
     250    //////////// UPDATERS /////////////
     251   
     252   
     253    @Override
     254    public int updateBody(Number annotationID, String serializedNewBody) {
     255        StringBuilder sql = new StringBuilder("UPDATE ");
     256        sql.append(annotationTableName).append(" SET ").append(body_xml).append("= '").append(serializedNewBody).append("' WHERE ").append(annotation_id).append("= ?");
     257        return getSimpleJdbcTemplate().update(sql.toString(), annotationID);
     258    }
     259
     260   
     261
     262 
     263   
     264    //////////// ADDERS ////////////////////////
    228265   
    229266   
    230     //////////////////////////////////////////////////////
    231     @Override
    232     public int deleteAnnotation(Number annotationID) throws SQLException {
    233         if (annotationIsInUse(annotationID)) {
    234             return 0;
    235         }
    236        
    237         String sqlAnnotation = "DELETE FROM " + annotationTableName + " where " + annotation_id + " = ?";
    238         return (getSimpleJdbcTemplate().update(sqlAnnotation, annotationID));
    239     }
    240    
    241     //////////////////////////////////////////////////////
    242     @Override
    243     public int deleteAllAnnotationSource(Number annotationID) throws SQLException {
    244         String sqlTargetSources = "DELETE FROM " + annotationsSourcesTableName + " where " + annotation_id + " = ?";
    245         return getSimpleJdbcTemplate().update(sqlTargetSources, annotationID); // removed "annotations_target_sources" rows
    246        
    247     }
    248    
    249 
    250     // TODO: so far URI in the xml is the same as the external_id in the DB!!
    251     // Change it when the decision is taken!!!
    252267    @Override
    253268    public Number addAnnotation(Annotation annotation, Number ownerID) throws SQLException {
    … …  
    271286
    272287    }
    273 
    274    
    275     ///////////////////////////////////////////////////////////////////////
    276     @Override
    277     public int updateBody(Number annotationID, String serializedNewBody) {
    278         StringBuilder sql = new StringBuilder("UPDATE ");
    279         sql.append(annotationTableName).append(" SET ").append(body_xml).append("= '").append(serializedNewBody).append("' WHERE ").append(annotation_id).append("= ?");
    280         return getSimpleJdbcTemplate().update(sql.toString(), annotationID);
    281     }
    282 
    283    
    284 
    285  
     288   
    286289    //////////////////////////////////////////////////////////////////////////////////
    287290    @Override
    … …  
    296299    //////////////////////////////////////////////////////////////////////////////////
    297300
     301   
     302    //////////////////////////////////////////////////////
     303    @Override
     304    public int deleteAnnotation(Number annotationID) throws SQLException {
     305        if (annotationIsInUse(annotationID)) {
     306            return 0;
     307        }
     308       
     309        String sqlAnnotation = "DELETE FROM " + annotationTableName + " where " + annotation_id + " = ?";
     310        return (getSimpleJdbcTemplate().update(sqlAnnotation, annotationID));
     311    }
     312   
     313    //////////////////////////////////////////////////////
     314    @Override
     315    public int deleteAllAnnotationSource(Number annotationID) throws SQLException {
     316        String sqlTargetSources = "DELETE FROM " + annotationsSourcesTableName + " where " + annotation_id + " = ?";
     317        return getSimpleJdbcTemplate().update(sqlTargetSources, annotationID); // removed "annotations_target_sources" rows
     318       
     319    }
     320   
     321
     322 
     323   
    298324    /////////////// helpers //////////////////
    299325   
    … …  
    305331    }
    306332   
    307         //////////////////////////////
    308     private boolean annotationIsInUse(Number sourceID) {
    309         String sql = "SELECT " + notebook_id + " FROM " + notebooksAnnotationsTableName + " WHERE " + annotation_id + "= ? LIMIT 1";
    310         List<Number> result = getSimpleJdbcTemplate().query(sql, notebookIDRowMapper, sourceID);
    311         if (result.size() > 0) {
    312             return true;
    313         }
    314         return false;
    315     }
    316    
    317       private final RowMapper<Number> notebookIDRowMapper = new RowMapper<Number>() {
    318         @Override
    319         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    320             return rs.getInt(notebook_id);
    321         }
    322     };
    323    
     333 
    324334    //////////////////////////////////////////////////////
    325335    @Override

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcCachedRepresentationDao.java

    r3455 r3459  
    4545 
    4646
    47     ///////////////////////////////////////////////////////////////////////////////////////
     47    /////////////////////////// GETTERS  ////////////////////////////////////////
    4848    @Override
    4949    public CachedRepresentationInfo getCachedRepresentationInfo(Number internalID) {
    … …  
    7272        }
    7373    };
     74   
     75    //////////////////////////////////////
    7476
    75     ////////////////////////////////////////////////////////////////////////////
     77    private boolean cachedIsInUse(Number cachedID) {     
     78        String sql = "SELECT " + version_id + " FROM " + versionsCachedRepresentationsTableName + " WHERE " + cached_representation_id + "= ? LIMIT 1";
     79        List<Number> result = getSimpleJdbcTemplate().query(sql, versionIDRowMapper, cachedID);
     80        if (result.size() > 0) {
     81            return true;
     82        }
     83        return false;
     84    }
     85   
     86 
     87
     88    //////////////////////// ADDERS ///////////////////////////////
    7689    @Override
    7790    public Number addCachedRepresentationInfo(CachedRepresentationInfo cached) {
    … …  
    88101    }
    89102
    90     //////////////////////////////////////////////////////////////////////////////////////////////
     103    /////////////////////// DELETERS  //////////////////////////////////////////////
    91104    @Override
    92105    public int deleteCachedRepresentationInfo(Number internalID) {
    … …  
    100113   
    101114   
    102    
    103    
    104     //////////////// PRIVATE ////////////////////////
    105 
    106     private boolean cachedIsInUse(Number cachedID) {     
    107         String sql = "SELECT " + version_id + " FROM " + versionsCachedRepresentationsTableName + " WHERE " + cached_representation_id + "= ? LIMIT 1";
    108         List<Number> result = getSimpleJdbcTemplate().query(sql, versionIDRowMapper, cachedID);
    109         if (result.size() > 0) {
    110             return true;
    111         }
    112         return false;
    113     }
    114    
    115     private final RowMapper<Number> versionIDRowMapper = new RowMapper<Number>() {
    116         @Override
    117         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    118             return rs.getInt(version_id);
    119         }
    120     };
    121    
    122    
    123115}

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcResourceDao.java

    r3455 r3459  
    103103        return result;
    104104    }
    105     protected final RowMapper<Number> internalIDRowMapper = new RowMapper<Number>() {
    106         @Override
    107         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    108             int result = rs.getInt(internalIdName);
    109             Number resultNumber = result;
    110             return resultNumber;
    111         }
    112     };
    113 
    114    
     105
    115106    @Override
    116107    public UUID getExternalID(Number internalId) {
    … …  
    123114        return (sqlResult.get(0));
    124115    }
    125    
    126     protected final RowMapper<UUID> externalIDRowMapper = new RowMapper<UUID>() {
    127         @Override
    128         public UUID mapRow(ResultSet rs, int rowNumber) throws SQLException {
    129             return (UUID.fromString(rs.getString(external_id)));
    130         }
    131     };
    132116
    133117    /////////////////////////////////////////////////////
    … …  
    171155        return result;
    172156    }
     157   
     158   
     159    ////////////////// ROW MAPPERS ///////////////////
     160   
     161   
     162    protected final RowMapper<Number> internalIDRowMapper = new RowMapper<Number>() {
     163        @Override
     164        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
     165            int result = rs.getInt(internalIdName);
     166            Number resultNumber = result;
     167            return resultNumber;
     168        }
     169    };
     170    protected final RowMapper<UUID> externalIDRowMapper = new RowMapper<UUID>() {
     171        @Override
     172        public UUID mapRow(ResultSet rs, int rowNumber) throws SQLException {
     173            return (UUID.fromString(rs.getString(external_id)));
     174        }
     175    };
     176    protected final RowMapper<Number> cachedIDRowMapper = new RowMapper<Number>() {
     177        @Override
     178        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
     179            return rs.getInt(cached_representation_id);
     180        }
     181    };
     182    protected final RowMapper<Number> sourceIDRowMapper = new RowMapper<Number>() {
     183        @Override
     184        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
     185            return rs.getInt(source_id);
     186        }
     187    };
     188    protected final RowMapper<Number> versionIDRowMapper = new RowMapper<Number>() {
     189        @Override
     190        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
     191            return rs.getInt(version_id);
     192        }
     193    };
     194    protected final RowMapper<Number> annotationIDRowMapper = new RowMapper<Number>() {
     195        @Override
     196        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
     197            return rs.getInt(annotation_id);
     198        }
     199    };
     200    protected final RowMapper<Number> notebookIDRowMapper = new RowMapper<Number>() {
     201        @Override
     202        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
     203            return rs.getInt(notebook_id);
     204        }
     205    };
     206     protected final RowMapper<Number> principalIDRowMapper = new RowMapper<Number>() {
     207        @Override
     208        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
     209            return rs.getInt(principal_id);
     210        }
     211    };
    173212}

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcSourceDao.java

    r3455 r3459  
    4747    }
    4848
    49    
    50 
    51     ///////////////////////////////////////////////////////////////////////////////
     49
     50    //////////////////////// GETTERS ///////////////////////////////////
    5251    @Override
    5352    public Source getSource(Number internalID) {
    … …  
    7170        }
    7271    };
    73 
    74     ///////////////////////////////////////////////////////////////////
    75     @Override
    76     public int deleteSource(Number internalID) {
    77         if (sourceIsInUse(internalID)){
    78             return 0;
    79         }
    80         String sqlSourcesVersions = "DELETE FROM " + sourceTableName + " WHERE " + source_id + " = ? ";
    81         int result = getSimpleJdbcTemplate().update(sqlSourcesVersions, internalID);
    82         return result;
    83 
    84     }
    85 
    86    
    87     ///////////////////////////////////////////////////////////////////
    88     @Override
    89     public int deleteAllSourceVersion(Number internalID) {
    90         String sqlSourcesVersions = "DELETE FROM " + sourcesVersionsTableName + " WHERE " + source_id + " = ?";
    91         int result = getSimpleJdbcTemplate().update(sqlSourcesVersions, internalID);
    92         return result;
    93 
    94     }
    95 
    96     ///////////////////////////////////////////////////////////////////
     72   
     73    /////////////////////////////////////////
     74    @Override
     75    public List<Number> retrieveVersionList(Number sourceID) {
     76        String sql = "SELECT " + version_id + " FROM " + sourcesVersionsTableName + " WHERE " + source_id + " = ?";
     77        List<Number> result = getSimpleJdbcTemplate().query(sql, versionIDRowMapper, sourceID);
     78        return result;
     79    }
     80
     81   
     82     ///////////////////////////////////////////////////////////////////
     83    @Override
     84    public List<SourceInfo> getSourceInfos(List<Number> sources) {
     85        if (sources == null) {
     86            return null;
     87        }
     88        if (sources.isEmpty()) {
     89            return new ArrayList<SourceInfo>();
     90        }
     91
     92        String sourceIDs = makeListOfValues(sources);
     93        String sql = "SELECT " + external_id + "," + link_uri + "," + version + " FROM " + sourceTableName + " WHERE " + source_id + " IN " + sourceIDs;
     94        List<SourceInfo> result = getSimpleJdbcTemplate().query(sql, SourceInfoRowMapper);
     95        return result;
     96    }
     97    private final RowMapper<SourceInfo> SourceInfoRowMapper = new RowMapper<SourceInfo>() {
     98        @Override
     99        public SourceInfo mapRow(ResultSet rs, int rowNumber) throws SQLException {
     100            return constructSourceInfo(UUID.fromString(rs.getString(external_id)), rs.getString(link_uri), rs.getString(version));
     101        }
     102    };
     103
     104 
     105    /////////////////////////////////////////////////////
     106    @Override
     107    public List<Number> getSourcesForLink(String link) {
     108        StringBuilder sql = new StringBuilder("SELECT ");
     109        sql.append(source_id).append(" FROM ").append(sourceTableName).append(" WHERE ").append(link_uri).append(" LIKE '%").append(link).append("%'");
     110        List<Number> result = getSimpleJdbcTemplate().query(sql.toString(), internalIDRowMapper);
     111        return result;
     112    }
     113
     114   
     115    /////////////////////////////////////////////////
     116    @Override
     117    public boolean sourceIsInUse(Number sourceID) {
     118        String sqlAnnotations = "SELECT " + annotation_id + " FROM " + annotationsSourcesTableName + " WHERE " + source_id + "= ? LIMIT 1";
     119        List<Number> resultAnnotations = getSimpleJdbcTemplate().query(sqlAnnotations, annotationIDRowMapper, sourceID);
     120        if (resultAnnotations.size() > 0) {
     121            return true;
     122        }
     123        String sqlVersions = "SELECT " + version_id + " FROM " + sourcesVersionsTableName + " WHERE " + source_id + "= ? LIMIT 1";
     124        List<Number> resultVersions = getSimpleJdbcTemplate().query(sqlVersions, versionIDRowMapper, sourceID);
     125        if (resultVersions.size() > 0) {
     126            return true;
     127        }
     128        return false;
     129    }
     130   
     131 
     132   
     133
     134    ///////////////////////// ADDERS /////////////////////////////////
    97135    @Override
    98136    public Number addSource(Source source) throws SQLException {       
    … …  
    108146    }
    109147   
    110     ///////////////////////////////
    111    
    112148   
    113149    ///////////////////////////////////////////////////////////////////
    … …  
    121157    }
    122158   
    123 
    124     /////////////////////////////////////////
    125     @Override
    126     public List<Number> retrieveVersionList(Number sourceID) {
    127         String sql = "SELECT " + version_id + " FROM " + sourcesVersionsTableName + " WHERE " + source_id + " = ?";
    128         List<Number> result = getSimpleJdbcTemplate().query(sql, versionsSourcesRunnerRowMapper, sourceID);
    129         return result;
    130     }
    131     private final RowMapper<Number> versionsSourcesRunnerRowMapper = new RowMapper<Number>() {
    132         @Override
    133         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    134             Number result = rs.getInt(version_id);
    135             return result;
    136         }
    137     };
    138 
     159////////////////////// DELETERS ////////////////////////
     160    @Override
     161    public int deleteSource(Number internalID) {
     162        if (sourceIsInUse(internalID)){
     163            return 0;
     164        }
     165        String sqlSourcesVersions = "DELETE FROM " + sourceTableName + " WHERE " + source_id + " = ? ";
     166        int result = getSimpleJdbcTemplate().update(sqlSourcesVersions, internalID);
     167        return result;
     168
     169    }
     170
     171   
    139172    ///////////////////////////////////////////////////////////////////
    140173    @Override
    141     public List<SourceInfo> getSourceInfos(List<Number> sources) {
    142         if (sources == null) {
    143             return null;
    144         }
    145         if (sources.isEmpty()) {
    146             return new ArrayList<SourceInfo>();
    147         }
    148 
    149         String sourceIDs = makeListOfValues(sources);
    150         String sql = "SELECT " + external_id + "," + link_uri + "," + version + " FROM " + sourceTableName + " WHERE " + source_id + " IN " + sourceIDs;
    151         List<SourceInfo> result = getSimpleJdbcTemplate().query(sql, SourceInfoRowMapper);
    152         return result;
    153     }
    154     private final RowMapper<SourceInfo> SourceInfoRowMapper = new RowMapper<SourceInfo>() {
    155         @Override
    156         public SourceInfo mapRow(ResultSet rs, int rowNumber) throws SQLException {
    157             return constructSourceInfo(UUID.fromString(rs.getString(external_id)), rs.getString(link_uri), rs.getString(version));
    158         }
    159     };
    160 
     174    public int deleteAllSourceVersion(Number internalID) {
     175        String sqlSourcesVersions = "DELETE FROM " + sourcesVersionsTableName + " WHERE " + source_id + " = ?";
     176        int result = getSimpleJdbcTemplate().update(sqlSourcesVersions, internalID);
     177        return result;
     178
     179    }
    161180 
    162     /////////////////////////////////////////////////////
    163     @Override
    164     public List<Number> getSourcesForLink(String link) {
    165         StringBuilder sql = new StringBuilder("SELECT ");
    166         sql.append(source_id).append(" FROM ").append(sourceTableName).append(" WHERE ").append(link_uri).append(" LIKE '%").append(link).append("%'");
    167         List<Number> result = getSimpleJdbcTemplate().query(sql.toString(), internalIDRowMapper);
    168         return result;
    169     }
    170 
    171    
    172 
    173     @Override
    174     public boolean sourceIsInUse(Number sourceID) {
    175         String sql = "SELECT " + annotation_id + " FROM " + annotationsSourcesTableName + " WHERE " + source_id + "= ? LIMIT 1";
    176         List<Number> result = getSimpleJdbcTemplate().query(sql, annotationIDRowMapper, sourceID);
    177         if (result.size() > 0) {
    178             return true;
    179         }
    180         return false;
    181     }
    182    
    183       private final RowMapper<Number> annotationIDRowMapper = new RowMapper<Number>() {
    184         @Override
    185         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    186             return rs.getInt(annotation_id);
    187         }
    188     };
    189    
     181   
    190182  /////////// HELPERS  ////////////////
    191183   

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcVersionDao.java

    r3455 r3459  
    4343
    4444 
    45     ///////////////////////////////////////////////////////////////
     45    /////////////// GETTERS /////////////////////
    4646    @Override
    4747    public Version getVersion(Number internalID) {
    … …  
    4949        String sql = "SELECT " + versionStar + " FROM " + versionTableName + " WHERE " + version_id + "= ? LIMIT 1";
    5050        List<Version> result = getSimpleJdbcTemplate().query(sql, versionRowMapper, internalID);
    51 
    52         if (result == null) {
    53             return null;
    54         }
    5551        if (result.isEmpty()) {
    5652            return null;
    … …  
    7874    }
    7975
    80     private final RowMapper<Number> cachedIDRowMapper = new RowMapper<Number>() {
    81         @Override
    82         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    83             return rs.getInt(cached_representation_id);
     76 
     77   
     78    ///////////////////////////////////////////////////////////////
     79   
     80    @Override
     81    public boolean versionIsInUse(Number versionsID) {
     82        String sqlSources = "SELECT " + source_id + " FROM " + sourcesVersionsTableName + " WHERE " + version_id + "= ? LIMIT 1";
     83        List<Number> resultSources = getSimpleJdbcTemplate().query(sqlSources, sourceIDRowMapper, versionsID);
     84        if (resultSources.size() > 0) {
     85            return true;
    8486        }
    85     };
     87        String sqlVersions = "SELECT " + cached_representation_id + " FROM " + versionsCachedRepresentationsTableName + " WHERE " + version_id + "= ? LIMIT 1";
     88        List<Number> resultCached = getSimpleJdbcTemplate().query(sqlVersions, cachedIDRowMapper, versionsID);
     89        if (resultCached.size() > 0) {
     90            return true;
     91        }
     92        return false;
     93    }
    8694   
    87     /////////////////////////////////////////
    88     @Override
    89     public int deleteVersion(Number internalID) {
    90        
    91         int result = 0;       
    92         if (versionIsInUse(internalID)) {
    93             return result;
    94         }
    95        
    96         String sql = "DELETE FROM " + versionTableName + " where " + version_id + " = ?";
    97         result = getSimpleJdbcTemplate().update(sql, internalID);     
    98         return result;
    99 
    100     }
    101 
    102     /////////////////////////////////////////////////
     95 
     96   
     97    /////////////////// ADDERS ///////////////////
     98   
    10399    @Override
    104100    public Number addVersion(Version freshVersion) {
    … …  
    114110        return getInternalID(externalIdentifier);
    115111    }
     112   
     113       ////////////////////////////////////////////
     114    @Override
     115    public int addVersionCachedRepresentation(Number versionID, Number cachedID){       
     116    Map<String, Object> params = new HashMap<String, Object>();
     117        params.put("versionId", versionID);
     118        params.put("cachedId", cachedID);
     119        String sql = "INSERT INTO " + versionsCachedRepresentationsTableName + "(" + version_id + "," + cached_representation_id + " ) VALUES (:versionId, :cachedId)";
     120        return getSimpleJdbcTemplate().update(sql, params);
     121    }
     122   
     123   
     124    /////////////// DELETERS ////////////////////////
     125   
     126    @Override
     127    public int deleteVersion(Number internalID) {
     128        if (versionIsInUse(internalID)) {
     129            return 0;
     130        }       
     131        String sql = "DELETE FROM " + versionTableName + " where " + version_id + " = ?";
     132        int result = getSimpleJdbcTemplate().update(sql, internalID);     
     133        return result;
     134
     135    }
     136
     137   
    116138   
    117139    ////////////////////////////////////////////
    … …  
    135157    }
    136158       
    137     ////////////////////////////////////////////
    138     @Override
    139     public int addVersionCachedRepresentation(Number versionID, Number cachedID){       
    140     Map<String, Object> params = new HashMap<String, Object>();
    141         params.put("versionId", versionID);
    142         params.put("cachedId", cachedID);
    143         String sql = "INSERT INTO " + versionsCachedRepresentationsTableName + "(" + version_id + "," + cached_representation_id + " ) VALUES (:versionId, :cachedId)";
    144         return getSimpleJdbcTemplate().update(sql, params);
    145     }
    146    
    147    
    148    
    149    
    150    
    151    
    152     @Override
    153     public boolean versionIsInUse(Number versionsID) {
    154         String sql = "SELECT " + source_id + " FROM " + sourcesVersionsTableName + " WHERE " + version_id + "= ? LIMIT 1";
    155         List<Number> result = getSimpleJdbcTemplate().query(sql, sourceIDRowMapper, versionsID);
    156         if (result.size() > 0) {
    157             return true;
    158         }
    159         return false;
    160     }
    161    
    162      private final RowMapper<Number> sourceIDRowMapper = new RowMapper<Number>() {
    163         @Override
    164         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    165             return rs.getInt(source_id);
    166         }
    167     };
     159 
     160 
    168161}
Note: See TracChangeset for help on using the changeset viewer.