Changeset 3264


Ignore:
Timestamp:
08/06/13 13:47:13 (11 years ago)
Author:
olhsha
Message:

refactored Version and CachedRepresentation? dao.

Location:
DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r3238 r3264  
    3434     */
    3535    public CachedRepresentationIdentifier getExternalId(Number internalID);
    36    
    37     /**
    38      *
    39      * @param externalID
    40      * @return internal identifier of the resource with externalID
    41      */
    42     public  Number getInternalId(CachedRepresentationIdentifier externalID);
    43    
     36 
    4437    /**
    4538     *

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

    r3188 r3264  
    1818package eu.dasish.annotation.backend.dao;
    1919
    20 import java.util.UUID;
     20import eu.dasish.annotation.backend.identifiers.DasishIdentifier;
    2121
    2222/**
    … …  
    2626public interface ResourceDao {
    2727   
     28     /**
     29     *
     30     * @param externalID
     31     * @return internal identifier of the resource with externalID
     32     */
     33    public <T extends DasishIdentifier> Number getInternalID(T externalId);
     34   
     35   
     36   
     37   
     38   
    2839     /**   
    2940     * @param notebookID
    … …  
    3142     * @return true if the notebook with notebookID in the DB
    3243     */
     44   
     45    // TODO: remoev this after notebooks are corrected so they do not use it!!
    3346    public boolean isNotebookInTheDataBase(Number notebookID);
    3447   

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

    r3239 r3264  
    3434     */
    3535   
    36     public VersionIdentifier getExternalId(Number internalID);
    37    
    38     /**
    39      *
    40      * @param externalID
    41      * @return internal identifier of the resource with externalID
    42      */
    43     public  Number getInternalId(VersionIdentifier externalID);
    44    
    45    
     36    public VersionIdentifier getExternalId(Number internalID);   
     37   
     38   
    4639    /**
    4740     *

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

    r3255 r3264  
    3333 * @author olhsha
    3434 */
    35 public class JdbcCachedRepresentationDao extends JdbcResourceDao implements CachedRepresentationDao{
    36    
    37      public JdbcCachedRepresentationDao(DataSource dataSource) {
     35public class JdbcCachedRepresentationDao extends JdbcResourceDao implements CachedRepresentationDao {
     36
     37    public JdbcCachedRepresentationDao(DataSource dataSource) {
    3838        setDataSource(dataSource);
     39        internalIdName = cached_representation_id;
     40        resourceTableName = cachedRepresentationTableName;
    3941    }
    40      
    41    //////////////////////////////////////////////////////////////////////////////////////////////////////
    42      @Override
    43      public CachedRepresentationIdentifier getExternalId(Number internalID){
    44        if (internalID == null) {
     42
     43    //////////////////////////////////////////////////////////////////////////////////////////////////////
     44    @Override
     45    public CachedRepresentationIdentifier getExternalId(Number internalID) {
     46        if (internalID == null) {
    4547            return null;
    4648        }
    47        String sql = "SELECT "+external_id+" FROM "+cachedRepresentationTableName+" WHERE "+cached_representation_id  +"= ?";
    48        List<String> sqlResult= getSimpleJdbcTemplate().query(sql, externalIDRowMapper, internalID);
    49        
    50        if (sqlResult == null) {
    51            return null;
    52        }
    53        if (sqlResult.isEmpty()) {
    54            return null;
    55        }
    56        
    57         CachedRepresentationIdentifier result  = new CachedRepresentationIdentifier(sqlResult.get(0));
     49        String sql = "SELECT " + external_id + " FROM " + cachedRepresentationTableName + " WHERE " + cached_representation_id + "= ?";
     50        List<String> sqlResult = getSimpleJdbcTemplate().query(sql, externalIDRowMapper, internalID);
     51
     52        if (sqlResult == null) {
     53            return null;
     54        }
     55        if (sqlResult.isEmpty()) {
     56            return null;
     57        }
     58
     59        CachedRepresentationIdentifier result = new CachedRepresentationIdentifier(sqlResult.get(0));
    5860        return result;
    59     } 
    60      
    61      private final RowMapper<String> externalIDRowMapper = new RowMapper<String>() {       
     61    }
     62    private final RowMapper<String> externalIDRowMapper = new RowMapper<String>() {
    6263        @Override
    6364        public String mapRow(ResultSet rs, int rowNumber) throws SQLException {
    64             return(rs.getString(external_id));
     65            return (rs.getString(external_id));
    6566        }
    66      }; 
    67      
    68       //////////////////////////////////////////////////////////////////////////////////////////////////////
    69      @Override
    70      public Number getInternalId(CachedRepresentationIdentifier externalID){
    71        if (externalID == null) {
     67    };
     68
     69   
     70    @Override
     71    public CachedRepresentationInfo getCachedRepresentationInfo(Number internalID) {
     72
     73        String sql = "SELECT " + cachedRepresentationStar + " FROM " + cachedRepresentationTableName + " WHERE " + cached_representation_id + "= ?";
     74        List<CachedRepresentationInfo> result = getSimpleJdbcTemplate().query(sql, cachedRepresentationRowMapper, internalID);
     75
     76        if (result == null) {
    7277            return null;
    7378        }
    74        String sql = "SELECT "+cached_representation_id+" FROM "+cachedRepresentationTableName+" WHERE "+external_id  +"= ?";
    75        List<Number> sqlResult= getSimpleJdbcTemplate().query(sql, internalIDRowMapper, externalID.toString());
    76        
    77        if (sqlResult == null) {
    78            return null;
    79        }
    80        if (sqlResult.isEmpty()) {
    81            return null;
    82        }
    83        
    84         Number result  = sqlResult.get(0);
    85         return result;
    86     } 
    87      
    88      private final RowMapper<Number> internalIDRowMapper = new RowMapper<Number>() {       
    89         @Override
    90         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    91             int result = rs.getInt(cached_representation_id);
    92             Number resultNumber =  result;
    93             return resultNumber;
     79        if (result.isEmpty()) {
     80            return null;
    9481        }
    95      };
    96      
    97      ///////////////////////////////////////////////////////////////
    98      @Override
    99      public CachedRepresentationInfo getCachedRepresentationInfo(Number internalID){
    100          
    101        String sql = "SELECT "+cachedRepresentationStar+" FROM "+cachedRepresentationTableName+" WHERE "+cached_representation_id  +"= ?";
    102        List<CachedRepresentationInfo> result= getSimpleJdbcTemplate().query(sql, cachedRepresentationRowMapper, internalID);
    103        
    104        if (result == null) {
    105            return null;
    106        }
    107        if (result.isEmpty()) {
    108            return null;
    109        }
    110        return result.get(0);
    111      }
    112      
    113      private final RowMapper<CachedRepresentationInfo> cachedRepresentationRowMapper = new RowMapper<CachedRepresentationInfo>() {       
     82        return result.get(0);
     83    }
     84    private final RowMapper<CachedRepresentationInfo> cachedRepresentationRowMapper = new RowMapper<CachedRepresentationInfo>() {
    11485        @Override
    11586        public CachedRepresentationInfo mapRow(ResultSet rs, int rowNumber) throws SQLException {
    … …  
    12394            return result;
    12495        }
    125      };
    126      
    127      
    128      ////////////////////////////////////////////////////////////////////////////
    129       @Override
    130       public List<Number> retrieveCachedRepresentationList(Number versionID){
    131        String sql = "SELECT "+cached_representation_id+" FROM "+versionsCachedRepresentationsTableName+" WHERE "+version_id  +"= ?";
    132        List<Number> result= getSimpleJdbcTemplate().query(sql, internalIDRowMapper, versionID);
    133        
    134        if (result == null) {
    135            return null;
    136        }
    137        if (result.isEmpty()) {
    138            return null;
    139        }
    140        return result;
    141       };
     96    };
     97
     98    ////////////////////////////////////////////////////////////////////////////
     99    @Override
     100    public List<Number> retrieveCachedRepresentationList(Number versionID) {
     101        String sql = "SELECT " + cached_representation_id + " FROM " + versionsCachedRepresentationsTableName + " WHERE " + version_id + "= ?";
     102        List<Number> result = getSimpleJdbcTemplate().query(sql, internalIDRowMapper, versionID);
     103
     104        if (result == null) {
     105            return null;
     106        }
     107        if (result.isEmpty()) {
     108            return null;
     109        }
     110        return result;
     111    }
     112
     113    ;
    142114     
    143115      ////////////////////////////////////////////////////////////////////////////
    144116      @Override
    145       public int deleteCachedRepresentationInfo(Number internalID){
    146         String sql = "DELETE FROM " + cachedRepresentationTableName + " where "+cached_representation_id + " = ?";
     117    public int deleteCachedRepresentationInfo(Number internalID) {
     118        String sql = "DELETE FROM " + cachedRepresentationTableName + " where " + cached_representation_id + " = ?";
    147119        return (getSimpleJdbcTemplate().update(sql, internalID));
    148       };
     120    }
     121
     122    ;
    149123     
    150124      ////////////////////////////////////////////////////////////////////////////
    151125      @Override
    152       public CachedRepresentationInfo addCachedRepresentationInfo(CachedRepresentationInfo cached){
    153          
    154           CachedRepresentationIdentifier externalIdentifier = new CachedRepresentationIdentifier();
    155          
    156           Map<String, Object> params = new HashMap<String, Object>();
    157           params.put("externalId", externalIdentifier.toString());
    158           params.put("mime_type", cached.getMimeType());
    159           params.put("tool", cached.getTool());
    160           params.put("type", cached.getType());
    161           String sql = "INSERT INTO "+cachedRepresentationTableName + "("+external_id+","+ mime_type+"," + tool+","+type_+" ) VALUES (:externalId, :mime_type,  :tool, :type)";
    162           final int affectedRows = getSimpleJdbcTemplate().update(sql, params);
    163          
    164           CachedRepresentationInfo cachedNew = makeFreshCopy(cached);
    165           cachedNew.setRef(externalIdentifier.toString());
    166          
    167           return cachedNew;
    168       }
    169      
    170       //////////////////////////////////////////////////////////////////////////////////////////////
    171       @Override
    172       public int purge(Number internalID){       
    173        String sqlCheck = "SELECT "+cached_representation_id+" FROM "+versionsCachedRepresentationsTableName+" WHERE "+cached_representation_id  +"= ?";
    174        List<Number> result= getSimpleJdbcTemplate().query(sqlCheck, cachedRepresentationCheckerRowMapper, internalID);
    175        if (result.size() < 1) {
    176            String sql ="DELETE FROM " + cachedRepresentationTableName + " where "+cached_representation_id + " = ?";
    177            return getSimpleJdbcTemplate().update(sql,  internalID);
    178        }
    179        else {
    180            return 0;
    181        }
    182      }
    183      
    184      private final RowMapper<Number> cachedRepresentationCheckerRowMapper = new RowMapper<Number>() {       
     126    public CachedRepresentationInfo addCachedRepresentationInfo(CachedRepresentationInfo cached) {
     127
     128        CachedRepresentationIdentifier externalIdentifier = new CachedRepresentationIdentifier();
     129
     130        Map<String, Object> params = new HashMap<String, Object>();
     131        params.put("externalId", externalIdentifier.toString());
     132        params.put("mime_type", cached.getMimeType());
     133        params.put("tool", cached.getTool());
     134        params.put("type", cached.getType());
     135        String sql = "INSERT INTO " + cachedRepresentationTableName + "(" + external_id + "," + mime_type + "," + tool + "," + type_ + " ) VALUES (:externalId, :mime_type,  :tool, :type)";
     136        final int affectedRows = getSimpleJdbcTemplate().update(sql, params);
     137
     138        CachedRepresentationInfo cachedNew = makeFreshCopy(cached);
     139        cachedNew.setRef(externalIdentifier.toString());
     140
     141        return cachedNew;
     142    }
     143
     144    //////////////////////////////////////////////////////////////////////////////////////////////
     145    @Override
     146    public int purge(Number internalID) {
     147        String sqlCheck = "SELECT " + cached_representation_id + " FROM " + versionsCachedRepresentationsTableName + " WHERE " + cached_representation_id + "= ?";
     148        List<Number> result = getSimpleJdbcTemplate().query(sqlCheck, cachedRepresentationCheckerRowMapper, internalID);
     149        if (result.size() < 1) {
     150            String sql = "DELETE FROM " + cachedRepresentationTableName + " where " + cached_representation_id + " = ?";
     151            return getSimpleJdbcTemplate().update(sql, internalID);
     152        } else {
     153            return 0;
     154        }
     155    }
     156    private final RowMapper<Number> cachedRepresentationCheckerRowMapper = new RowMapper<Number>() {
    185157        @Override
    186158        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    … …  
    188160            return result;
    189161        }
    190      };
    191      
    192      //////////////////////////////////////////////////////////////////////////////////////////////
    193       @Override
    194       public List<Number> cachedRepresentationIDs(){       
    195        String sqlCheck = "SELECT "+cached_representation_id+" FROM "+cachedRepresentationTableName;
    196        List<Number> result= getSimpleJdbcTemplate().query(sqlCheck, cachedRepresentationRunnerRowMapper);
    197        return result;
    198      }
    199      
    200      private final RowMapper<Number> cachedRepresentationRunnerRowMapper = new RowMapper<Number>() {       
     162    };
     163
     164    //////////////////////////////////////////////////////////////////////////////////////////////
     165    @Override
     166    public List<Number> cachedRepresentationIDs() {
     167        String sqlCheck = "SELECT " + cached_representation_id + " FROM " + cachedRepresentationTableName;
     168        List<Number> result = getSimpleJdbcTemplate().query(sqlCheck, cachedRepresentationRunnerRowMapper);
     169        return result;
     170    }
     171    private final RowMapper<Number> cachedRepresentationRunnerRowMapper = new RowMapper<Number>() {
    201172        @Override
    202173        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    … …  
    204175            return result;
    205176        }
    206      };
    207      
    208      
    209      @Override
    210      public int purgeAll(){
    211          List<Number> ids = cachedRepresentationIDs();         
    212          return super.purgeAll(ids, this);
    213      }
    214      
    215       ////////// Helpers ///////////////////
    216      
    217       private CachedRepresentationInfo makeFreshCopy(CachedRepresentationInfo cached){
    218           CachedRepresentationInfo result = new CachedRepresentationInfo();
    219           result.setMimeType(cached.getMimeType());
    220           result.setRef(cached.getRef());
    221           result.setTool(cached.getTool());
    222           result.setType(cached.getType());
    223           return result;
    224       }
     177    };
     178
     179    @Override
     180    public int purgeAll() {
     181        List<Number> ids = cachedRepresentationIDs();
     182        return super.purgeAll(ids, this);
     183    }
     184
     185    ////////// Helpers ///////////////////
     186    private CachedRepresentationInfo makeFreshCopy(CachedRepresentationInfo cached) {
     187        CachedRepresentationInfo result = new CachedRepresentationInfo();
     188        result.setMimeType(cached.getMimeType());
     189        result.setRef(cached.getRef());
     190        result.setTool(cached.getTool());
     191        result.setType(cached.getType());
     192        return result;
     193    }
    225194}

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

    r3241 r3264  
    1919
    2020import eu.dasish.annotation.backend.dao.ResourceDao;
     21import eu.dasish.annotation.backend.identifiers.DasishIdentifier;
    2122import java.sql.ResultSet;
    2223import java.sql.SQLException;
    2324import java.util.List;
    24 import java.util.UUID;
    2525import org.springframework.jdbc.core.RowMapper;
    2626import org.springframework.jdbc.core.simple.SimpleJdbcDaoSupport;
    … …  
    9494    final static protected String versionStar = versionTableName+".*";
    9595   
     96    ///////////////////////////////////////////////////
     97   
     98    protected String internalIdName=null;
     99    protected String resourceTableName=null;
     100   
     101   
     102    @Override
     103    public <T extends DasishIdentifier> Number getInternalID(T externalId){
     104       if (externalId == null) {
     105            return null;
     106        }
     107       String sql = "SELECT "+internalIdName+" FROM "+resourceTableName+" WHERE "+external_id  +"= ?";
     108       List<Number> sqlResult= getSimpleJdbcTemplate().query(sql, internalIDRowMapper, externalId.toString());
     109       
     110       if (sqlResult == null) {
     111           return null;
     112       }
     113       if (sqlResult.isEmpty()) {
     114           return null;
     115       }
     116       
     117        Number result  = sqlResult.get(0);
     118        return result;
     119    } 
     120     
     121     protected final RowMapper<Number> internalIDRowMapper = new RowMapper<Number>() {       
     122        @Override
     123        public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
     124            int result = rs.getInt(internalIdName);
     125            Number resultNumber =  result;
     126            return resultNumber;
     127        }
     128     };
     129   
    96130    //////////////////////////////////////////
    97131    /**

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

    r3255 r3264  
    2020import eu.dasish.annotation.backend.dao.VersionDao;
    2121import eu.dasish.annotation.backend.identifiers.VersionIdentifier;
    22 import eu.dasish.annotation.schema.CachedRepresentationInfo;
    2322import eu.dasish.annotation.schema.Version;
    2423import java.sql.ResultSet;
    … …  
    3635public class JdbcVersionDao extends JdbcResourceDao implements VersionDao{
    3736   
    38       public JdbcVersionDao(DataSource dataSource) {
    39         setDataSource(dataSource);
     37      public JdbcVersionDao(DataSource dataSource) {         
     38        setDataSource(dataSource);       
     39        internalIdName = version_id;
     40        resourceTableName = versionTableName;
    4041    }
    4142     
    … …  
    6667        }
    6768     };
    68      
    69       //////////////////////////////////////////////////////////////////////////////////////////////////////
    70      @Override
    71      public Number getInternalId(VersionIdentifier externalID){
    72        if (externalID == null) {
    73             return null;
    74         }
    75        String sql = "SELECT "+version_id+" FROM "+versionTableName+" WHERE "+external_id  +"= ?";
    76        List<Number> sqlResult= getSimpleJdbcTemplate().query(sql, internalIDRowMapper, externalID.toString());
    77        
    78        if (sqlResult == null) {
    79            return null;
    80        }
    81        if (sqlResult.isEmpty()) {
    82            return null;
    83        }
    84        
    85         Number result  = sqlResult.get(0);
    86         return result;
    87     } 
    88      
    89      private final RowMapper<Number> internalIDRowMapper = new RowMapper<Number>() {       
    90         @Override
    91         public Number mapRow(ResultSet rs, int rowNumber) throws SQLException {
    92             return(rs.getInt(version_id));
    93         }
    94      };
    95      
    96      
     69   
    9770      ///////////////////////////////////////////////////////////////
    9871     @Override

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

    r3255 r3264  
    7474        CachedRepresentationIdentifier externalID = new CachedRepresentationIdentifier(TestBackendConstants._TEST_CACHED_REPRESENTATION_1_EXT_ID_);
    7575        Number expResult = 1;
    76         Number result = jdbcCachedRepresentationDao.getInternalId(externalID);
     76        Number result = jdbcCachedRepresentationDao.getInternalID(externalID);
    7777        assertEquals(expResult, result);
    7878    }

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

    r3255 r3264  
    6363        VersionIdentifier externalID = new VersionIdentifier(TestBackendConstants._TEST_VERSION_1_EXT_ID);
    6464        Number expResult = 1;
    65         Number result = jdbcVersionDao.getInternalId(externalID);
     65        Number result = jdbcVersionDao.getInternalID(externalID);
    6666        assertEquals(expResult, result);
    6767    }
Note: See TracChangeset for help on using the changeset viewer.