Source code

001// --------------------------------------------------------------------------------
002// Copyright 2002-2026 Echo Three, LLC
003//
004// Licensed under the Apache License, Version 2.0 (the "License");
005// you may not use this file except in compliance with the License.
006// You may obtain a copy of the License at
007//
008//     http://www.apache.org/licenses/LICENSE-2.0
009//
010// Unless required by applicable law or agreed to in writing, software
011// distributed under the License is distributed on an "AS IS" BASIS,
012// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013// See the License for the specific language governing permissions and
014// limitations under the License.
015// --------------------------------------------------------------------------------
016// Generated File -- DO NOT EDIT BY HAND
017// --------------------------------------------------------------------------------
018
019/**
020 * LanguageFactory.java
021 */
022
023package com.echothree.model.data.party.server.factory;
024
025import com.echothree.model.data.party.common.LanguageConstants;
026import com.echothree.model.data.party.common.pk.LanguagePK;
027import com.echothree.model.data.party.server.value.LanguageValue;
028import com.echothree.model.data.party.server.entity.Language;
029import com.echothree.util.common.exception.PersistenceDatabaseException;
030import com.echothree.util.common.exception.PersistenceDatabaseUpdateException;
031import com.echothree.util.common.exception.PersistenceNotNullException;
032import com.echothree.util.server.persistence.BaseFactory;
033import com.echothree.util.server.persistence.EntityIdGenerator;
034import com.echothree.util.server.persistence.EntityPermission;
035import com.echothree.util.server.persistence.PersistenceDebugFlags;
036import com.echothree.util.server.persistence.Session;
037import java.sql.PreparedStatement;
038import java.sql.ResultSet;
039import java.sql.SQLException;
040import java.sql.Types;
041import java.io.ByteArrayInputStream;
042import java.io.StringReader;
043import java.util.ArrayList;
044import java.util.Collection;
045import java.util.HashSet;
046import java.util.List;
047import java.util.Map;
048import java.util.Set;
049import javax.enterprise.context.ApplicationScoped;
050import javax.enterprise.inject.spi.CDI;
051import javax.inject.Inject;
052import org.jooq.ResultQuery;
053import org.slf4j.Logger;
054import org.slf4j.LoggerFactory;
055
056@ApplicationScoped
057public class LanguageFactory
058        implements BaseFactory<LanguagePK, Language> {
059    
060    @Inject
061    Session session;
062    
063    //private static final Logger log = LoggerFactory.getLogger(LanguageFactory.class);
064    
065    final private static String SQL_SELECT_READ_ONLY = "SELECT lang_languageid, lang_languageisoname, lang_isdefault, lang_sortorder FROM languages WHERE lang_languageid = ?";
066    final private static String SQL_SELECT_READ_WRITE = "SELECT lang_languageid, lang_languageisoname, lang_isdefault, lang_sortorder FROM languages WHERE lang_languageid = ? FOR UPDATE";
067    final private static String SQL_INSERT = "INSERT INTO languages (lang_languageid, lang_languageisoname, lang_isdefault, lang_sortorder) VALUES (?, ?, ?, ?)";
068    final private static String SQL_UPDATE = "UPDATE languages SET lang_languageisoname = ?, lang_isdefault = ?, lang_sortorder = ? WHERE lang_languageid = ?";
069    final private static String SQL_DELETE = "DELETE FROM languages WHERE lang_languageid = ?";
070    final private static String SQL_VALID = "SELECT COUNT(*) FROM languages WHERE lang_languageid = ?";
071    
072    final public static String LANG_LANGUAGEID = "lang_languageid";
073    final public static String LANG_LANGUAGEISONAME = "lang_languageisoname";
074    final public static String LANG_ISDEFAULT = "lang_isdefault";
075    final public static String LANG_SORTORDER = "lang_sortorder";
076    
077    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(LanguageConstants.COMPONENT_VENDOR_NAME, LanguageConstants.ENTITY_TYPE_NAME);
078    
079    /** Creates a new instance of LanguageFactory */
080    protected LanguageFactory() {
081        super();
082    }
083    
084    public static LanguageFactory getInstance() {
085        return CDI.current().select(LanguageFactory.class).get();
086    }
087    
088    @Override
089    public String getComponentVendorName() {
090        return LanguageConstants.COMPONENT_VENDOR_NAME;
091    }
092    
093    @Override
094    public String getEntityTypeName() {
095        return LanguageConstants.ENTITY_TYPE_NAME;
096    }
097    
098    public PreparedStatement prepareStatement(String query) {
099        return session.prepareStatement(query);
100    }
101    
102    public LanguagePK getNextPK() {
103        return new LanguagePK(entityIdGenerator.getNextEntityId());
104    }
105    
106    public Set<LanguagePK> getPKsFromResultSetAsSet(ResultSet rs)
107            throws PersistenceDatabaseException {
108        Set<LanguagePK> _result = new HashSet<>();
109        
110        try {
111            while(rs.next()) {
112                _result.add(getPKFromResultSet(rs));
113            }
114        } catch (SQLException se) {
115            throw new PersistenceDatabaseException(se);
116        }
117        
118        return _result;
119    }
120    
121    public java.util.List<LanguagePK> getPKsFromResultSetAsList(ResultSet rs)
122            throws PersistenceDatabaseException {
123        java.util.List<LanguagePK> _result = new ArrayList<>();
124        
125        try {
126            while(rs.next()) {
127                _result.add(getPKFromResultSet(rs));
128            }
129        } catch (SQLException se) {
130            throw new PersistenceDatabaseException(se);
131        }
132        
133        return _result;
134    }
135    
136    public LanguagePK getPKFromResultSet(ResultSet rs)
137            throws PersistenceDatabaseException {
138        LanguagePK _result;
139        
140        try {
141            long lang_languageid = rs.getLong(LANG_LANGUAGEID);
142            Long _entityId = rs.wasNull() ? null : lang_languageid;
143            
144            _result = new LanguagePK(_entityId);
145        } catch (SQLException se) {
146            throw new PersistenceDatabaseException(se);
147        }
148        
149        return _result;
150    }
151    
152    public java.util.List<LanguageValue> getValuesFromPKs(Collection<LanguagePK> pks)
153            throws PersistenceDatabaseException {
154        java.util.List<LanguageValue> _values = new ArrayList<>(pks.size());
155        
156        for(LanguagePK _pk: pks) {
157            _values.add(getValueFromPK(_pk));
158        }
159        
160        return _values;
161    }
162    
163    public LanguageValue getValueFromPK(LanguagePK pk)
164            throws PersistenceDatabaseException {
165        LanguageValue _value;
166        
167        // See if we already have the entity in the session cache
168        Language _entity = (Language)session.getEntity(pk);
169        if(_entity == null)
170            _value = getEntityFromPK(EntityPermission.READ_ONLY, pk).getLanguageValue();
171        else
172            _value = _entity.getLanguageValue();
173        
174        return _value;
175    }
176    
177    public java.util.List<LanguageValue> getValuesFromResultSet(ResultSet rs)
178            throws PersistenceDatabaseException {
179        java.util.List<LanguageValue> _result = new ArrayList<>();
180        
181        try {
182            while(rs.next()) {
183                _result.add(getValueFromResultSet(rs));
184            }
185        } catch (SQLException se) {
186            throw new PersistenceDatabaseException(se);
187        }
188        
189        return _result;
190    }
191    
192    public LanguageValue getValueFromResultSet(ResultSet rs)
193            throws PersistenceDatabaseException {
194        LanguageValue _value;
195        
196        try {
197            Long lang_languageid = rs.getLong(LANG_LANGUAGEID);
198            LanguagePK _pk = new LanguagePK(lang_languageid);
199            
200            // See if we already have the entity in the session cache
201            Language _entity = (Language)session.getEntity(_pk);
202            
203            if(_entity == null) {
204                String lang_languageisoname = rs.getString(LANG_LANGUAGEISONAME);
205                if(rs.wasNull())
206                    lang_languageisoname = null;
207                
208                Boolean lang_isdefault = rs.getInt(LANG_ISDEFAULT) == 1;
209                if(rs.wasNull())
210                    lang_isdefault = null;
211                
212                Integer lang_sortorder = rs.getInt(LANG_SORTORDER);
213                if(rs.wasNull())
214                    lang_sortorder = null;
215                
216                _value = new LanguageValue(_pk, lang_languageisoname, lang_isdefault, lang_sortorder);
217            } else
218                _value = _entity.getLanguageValue();
219        } catch (SQLException se) {
220            throw new PersistenceDatabaseException(se);
221        }
222        
223        return _value;
224    }
225    
226    public java.util.List<Language> getEntitiesFromPKs(EntityPermission entityPermission, Collection<LanguagePK> pks)
227            throws PersistenceDatabaseException {
228        java.util.List<Language> _entities = new ArrayList<>(pks.size());
229        
230        for(LanguagePK _pk: pks) {
231            _entities.add(getEntityFromPK(entityPermission, _pk));
232        }
233        
234        return _entities;
235    }
236    
237    public Language getEntityFromValue(EntityPermission entityPermission, LanguageValue value) {
238        return getEntityFromPK(entityPermission, value.getPrimaryKey());
239    }
240    
241    public Language getEntityFromCache(LanguagePK pk) {
242        LanguageValue _value = (LanguageValue)session.getValueCache().get(pk);
243    
244        return _value == null ? null : new Language(_value, EntityPermission.READ_ONLY);
245    }
246    
247    public Language getEntityFromPK(EntityPermission entityPermission, LanguagePK pk)
248            throws PersistenceDatabaseException {
249        Language _entity;
250        
251        // See if we already have the entity in the session cache
252        _entity = (Language)session.getEntity(pk);
253        if(_entity != null) {
254            // If the requested permission is READ_WRITE, and the cached permission is
255            // READ_ONLY, then pretend that the cached object wasn't found, and create
256            // a new entity that is READ_WRITE.
257            if(entityPermission.equals(EntityPermission.READ_WRITE)) {
258                if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
259                    _entity = null;
260            }
261        }
262        
263        if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
264            _entity = getEntityFromCache(pk);
265        }
266        
267        if(_entity == null) {
268            PreparedStatement _ps = session.prepareStatement(entityPermission.equals(EntityPermission.READ_ONLY)? SQL_SELECT_READ_ONLY: SQL_SELECT_READ_WRITE);
269            long _entityId = pk.getEntityId();
270            ResultSet _rs = null;
271            
272            try {
273                _ps.setLong(1, _entityId);
274                _rs = _ps.executeQuery();
275                if(_rs.next()) {
276                    _entity = getEntityFromResultSet(entityPermission, _rs);
277                }
278            } catch (SQLException se) {
279                throw new PersistenceDatabaseException(se);
280            } finally {
281                if(_rs != null) {
282                    try {
283                        _rs.close();
284                    } catch (SQLException se) {
285                        // do nothing
286                    }
287                }
288            }
289        }
290        
291        return _entity;
292    }
293    
294    public Set<LanguagePK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
295            throws PersistenceDatabaseException {
296        Set<LanguagePK> _pks;
297        ResultSet _rs = null;
298        
299        try {
300            if(params.length != 0) {
301                Session.setQueryParams(ps, params);
302            }
303            
304            _rs = ps.executeQuery();
305            _pks = getPKsFromResultSetAsSet(_rs);
306            _rs.close();
307        } catch (SQLException se) {
308            throw new PersistenceDatabaseException(se);
309        } finally {
310            if(_rs != null) {
311                try {
312                    _rs.close();
313                } catch (SQLException se) {
314                    // do nothing
315                }
316            }
317        }
318        
319        return _pks;
320    }
321    
322    public java.util.List<LanguagePK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
323            throws PersistenceDatabaseException {
324        java.util.List<LanguagePK> _pks;
325        ResultSet _rs = null;
326        
327        try {
328            if(params.length != 0) {
329                Session.setQueryParams(ps, params);
330            }
331            
332            _rs = ps.executeQuery();
333            _pks = getPKsFromResultSetAsList(_rs);
334            _rs.close();
335        } catch (SQLException se) {
336            throw new PersistenceDatabaseException(se);
337        } finally {
338            if(_rs != null) {
339                try {
340                    _rs.close();
341                } catch (SQLException se) {
342                    // do nothing
343                }
344            }
345        }
346        
347        return _pks;
348    }
349    
350    public LanguagePK getPKFromQuery(PreparedStatement ps, final Object... params)
351            throws PersistenceDatabaseException {
352        LanguagePK _pk = null;
353        ResultSet _rs = null;
354        
355        try {
356            if(params.length != 0) {
357                Session.setQueryParams(ps, params);
358            }
359            
360            _rs = ps.executeQuery();
361            if(_rs.next()) {
362                _pk = getPKFromResultSet(_rs);
363            }
364            _rs.close();
365        } catch (SQLException se) {
366            throw new PersistenceDatabaseException(se);
367        } finally {
368            if(_rs != null) {
369                try {
370                    _rs.close();
371                } catch (SQLException se) {
372                    // do nothing
373                }
374            }
375        }
376        
377        return _pk;
378    }
379    
380    public java.util.List<Language> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
381            throws PersistenceDatabaseException {
382        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
383        
384        return getEntitiesFromQuery(entityPermission, ps, params);
385    }
386    
387    public java.util.List<Language> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
388            throws PersistenceDatabaseException {
389        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
390        
391        return getEntitiesFromQuery(entityPermission, ps);
392    }
393    
394    public java.util.List<Language> getEntitiesFromQuery(EntityPermission entityPermission, ResultQuery<?> query)
395            throws PersistenceDatabaseException {
396        PreparedStatement ps = session.prepareStatement(query.getSQL());
397        
398        return getEntitiesFromQuery(entityPermission, ps, query.getBindValues().toArray());
399    }
400    
401    public java.util.List<Language> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
402            throws PersistenceDatabaseException {
403        java.util.List<Language> _entities;
404        ResultSet _rs = null;
405        
406        try {
407            if(params.length != 0) {
408                Session.setQueryParams(ps, params);
409            }
410            
411            _rs = ps.executeQuery();
412            _entities = getEntitiesFromResultSet(entityPermission, _rs);
413            _rs.close();
414        } catch (SQLException se) {
415            throw new PersistenceDatabaseException(se);
416        } finally {
417            if(_rs != null) {
418                try {
419                    _rs.close();
420                } catch (SQLException se) {
421                    // do nothing
422                }
423            }
424        }
425        
426        return _entities;
427    }
428    
429    public Language getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
430            throws PersistenceDatabaseException {
431        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
432        
433        return getEntityFromQuery(entityPermission, ps, params);
434    }
435    
436    public Language getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
437            throws PersistenceDatabaseException {
438        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
439        
440        return getEntityFromQuery(entityPermission, ps);
441    }
442    
443    public Language getEntityFromQuery(EntityPermission entityPermission, ResultQuery<?> query)
444            throws PersistenceDatabaseException {
445        PreparedStatement ps = session.prepareStatement(query.getSQL());
446        
447        return getEntityFromQuery(entityPermission, ps, query.getBindValues().toArray());
448    }
449    
450    public Language getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
451            throws PersistenceDatabaseException {
452        Language _entity = null;
453        ResultSet _rs = null;
454        
455        try {
456            if(params.length != 0) {
457                Session.setQueryParams(ps, params);
458            }
459            
460            _rs = ps.executeQuery();
461            if(_rs.next()) {
462                _entity = getEntityFromResultSet(entityPermission, _rs);
463            }
464            _rs.close();
465        } catch (SQLException se) {
466            throw new PersistenceDatabaseException(se);
467        } finally {
468            if(_rs != null) {
469                try {
470                    _rs.close();
471                } catch (SQLException se) {
472                    // do nothing
473                }
474            }
475        }
476        
477        return _entity;
478    }
479    
480    public java.util.List<Language> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
481            throws PersistenceDatabaseException {
482        java.util.List<Language> _result = new ArrayList<>();
483        
484        try {
485            while(rs.next()) {
486                _result.add(getEntityFromResultSet(entityPermission, rs));
487            }
488        } catch (SQLException se) {
489            throw new PersistenceDatabaseException(se);
490        }
491        
492        return _result;
493    }
494    
495    public Language getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
496            throws PersistenceDatabaseException {
497        Language _entity;
498        
499        try {
500            Long lang_languageid = rs.getLong(LANG_LANGUAGEID);
501            LanguagePK _pk = new LanguagePK(lang_languageid);
502            
503            // See if we already have the entity in the session cache
504            _entity = (Language)session.getEntity(_pk);
505            if(_entity != null) {
506                // If the requested permission is READ_WRITE, and the cached permission is
507                // READ_ONLY, then pretend that the cached object wasn't found, and create
508                // a new entity that is READ_WRITE.
509                if(entityPermission.equals(EntityPermission.READ_WRITE)) {
510                    if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
511                        _entity = null;
512                }
513            }
514            boolean foundInSessionCache = _entity != null;
515            
516            if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
517                _entity = getEntityFromCache(_pk);
518            }
519            
520            if(_entity == null) {
521                String lang_languageisoname = rs.getString(LANG_LANGUAGEISONAME);
522                if(rs.wasNull())
523                    lang_languageisoname = null;
524                
525                Boolean lang_isdefault = rs.getInt(LANG_ISDEFAULT) == 1;
526                if(rs.wasNull())
527                    lang_isdefault = null;
528                
529                Integer lang_sortorder = rs.getInt(LANG_SORTORDER);
530                if(rs.wasNull())
531                    lang_sortorder = null;
532                
533                LanguageValue _value = new LanguageValue(_pk, lang_languageisoname, lang_isdefault, lang_sortorder);
534                _entity = new Language(_value, entityPermission);
535            }
536            
537            if(!foundInSessionCache) {
538                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
539                    session.putReadOnlyEntity(_pk, _entity);
540                    session.getValueCache().put(_entity.getLanguageValue());
541                } else {
542                    session.putReadWriteEntity(_pk, _entity);
543                }
544            }
545        } catch (SQLException se) {
546            throw new PersistenceDatabaseException(se);
547        }
548        
549        return _entity;
550    }
551    
552    private void bindForCreate(PreparedStatement _ps, LanguageValue _value)
553            throws SQLException {
554        _ps.setLong(1, _value.getEntityId());
555        
556        String lang_languageisoname = _value.getLanguageIsoName();
557        if(lang_languageisoname == null)
558            _ps.setNull(2, Types.VARCHAR);
559        else
560            _ps.setString(2, lang_languageisoname);
561            
562        Boolean lang_isdefault = _value.getIsDefault();
563        if(lang_isdefault == null)
564            _ps.setNull(3, Types.BIT);
565        else
566            _ps.setInt(3, lang_isdefault? 1: 0);
567            
568        Integer lang_sortorder = _value.getSortOrder();
569        if(lang_sortorder == null)
570            _ps.setNull(4, Types.INTEGER);
571        else
572            _ps.setInt(4, lang_sortorder);
573            
574    }
575    
576    public Language create(String languageIsoName, Boolean isDefault, Integer sortOrder)
577            throws PersistenceDatabaseException, PersistenceNotNullException {
578        LanguagePK _pk = getNextPK();
579        LanguageValue _value = new LanguageValue(_pk, languageIsoName, isDefault, sortOrder);
580        
581        PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
582        
583        try {
584            bindForCreate(_ps, _value);
585            
586            if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
587                int _count = _ps.executeUpdate();
588                
589                if(_count != 1) {
590                    throw new PersistenceDatabaseUpdateException("insert failed, _count = " + _count);
591                }
592            } else {
593                 _ps.executeUpdate();
594            }
595            
596            session.getValueCache().put(_value);
597        } catch (SQLException se) {
598            throw new PersistenceDatabaseException(se);
599        }
600        
601        Language _entity = new Language(_value, EntityPermission.READ_ONLY);
602        session.putReadOnlyEntity(_pk, _entity);
603        
604        return _entity;
605    }
606    
607    public void create(Collection<LanguageValue> _values)
608            throws PersistenceDatabaseException, PersistenceNotNullException {
609        int _size = _values.size();
610        
611        if(_size > 0) {
612            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
613            List<LanguageValue> _cacheValues = new ArrayList<>(_size);
614            
615            try {
616                for(LanguageValue _value : _values) {
617                    _value.setEntityId(entityIdGenerator.getNextEntityId());
618                    bindForCreate(_ps, _value);
619                    
620                    _ps.addBatch();
621                    
622                    _cacheValues.add(_value);
623                }
624                
625                if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
626                    int[] _counts = _ps.executeBatch();
627                    
628                    for(int _countOffset = 0 ; _countOffset < _size ; _countOffset++) {
629                        if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
630                            throw new PersistenceDatabaseUpdateException("batch insert failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
631                        }
632                    }
633                } else {
634                     _ps.executeBatch();
635                }
636                
637                _ps.clearBatch();
638            } catch (SQLException se) {
639                throw new PersistenceDatabaseException(se);
640            }
641            
642            _cacheValues.forEach((_cacheValue) -> {
643                Language _cacheEntity = new Language(_cacheValue, EntityPermission.READ_ONLY);
644                
645                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
646            });
647        }
648    }
649    
650    private boolean bindForStore(PreparedStatement _ps, LanguageValue _value)
651            throws SQLException {
652        boolean _hasBeenModified = _value.hasBeenModified();
653        
654        if(_hasBeenModified) {
655            String lang_languageisoname = _value.getLanguageIsoName();
656            if(lang_languageisoname == null)
657                _ps.setNull(1, Types.VARCHAR);
658            else
659                _ps.setString(1, lang_languageisoname);
660            
661            Boolean lang_isdefault = _value.getIsDefault();
662            if(lang_isdefault == null)
663                _ps.setNull(2, Types.BIT);
664            else
665                _ps.setInt(2, lang_isdefault? 1: 0);
666            
667            Integer lang_sortorder = _value.getSortOrder();
668            if(lang_sortorder == null)
669                _ps.setNull(3, Types.INTEGER);
670            else
671                _ps.setInt(3, lang_sortorder);
672            
673            _ps.setLong(4, _value.getPrimaryKey().getEntityId());
674            
675            _value.clearHasBeenModified();
676        }
677        
678        return _hasBeenModified;
679    }
680    
681    @Override
682    public void store(Language entity)
683            throws PersistenceDatabaseException {
684        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
685        
686        try {
687            LanguageValue _value = entity.getLanguageValue();
688            
689            if(bindForStore(_ps, _value)) {
690                if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
691                    int _count = _ps.executeUpdate();
692                    
693                    if(_count != 1) {
694                        throw new PersistenceDatabaseUpdateException("update failed, _count = " + _count);
695                    }
696                } else {
697                     _ps.executeUpdate();
698                }
699                
700                session.getValueCache().put(_value);
701            }
702        } catch (SQLException se) {
703            throw new PersistenceDatabaseException(se);
704        }
705    }
706    
707    @Override
708    public void store(Collection<Language> entities)
709            throws PersistenceDatabaseException {
710        if(entities.size() > 0) {
711            PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
712            int _modifiedEntities = 0;
713            
714            try {
715                for(Language entity : entities) {
716                    if(bindForStore(_ps, entity.getLanguageValue())) {
717                        _ps.addBatch();
718                        _modifiedEntities++;
719                    }
720                }
721                
722                if(_modifiedEntities != 0) {
723                    if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
724                        int[] _counts = _ps.executeBatch();
725                        
726                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
727                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
728                                throw new PersistenceDatabaseUpdateException("batch update failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
729                            }
730                        }
731                    } else {
732                         _ps.executeBatch();
733                    }
734                    
735                    _ps.clearBatch();
736                    
737                    entities.forEach((entity) -> {
738                        session.getValueCache().put(entity.getLanguageValue());
739                    });
740                }
741            } catch (SQLException se) {
742                throw new PersistenceDatabaseException(se);
743            }
744        }
745    }
746    
747    @Override
748    public void remove(Language entity)
749            throws PersistenceDatabaseException {
750        remove(entity.getPrimaryKey());
751    }
752    
753    @Override
754    public void remove(LanguagePK pk)
755            throws PersistenceDatabaseException {
756        PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
757        long _entityId = pk.getEntityId();
758        
759        try {
760            _ps.setLong(1, _entityId);
761            
762            if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
763                int _count = _ps.executeUpdate();
764                
765                if(_count != 1) {
766                    throw new PersistenceDatabaseUpdateException("remove failed, _count = " + _count);
767                }
768            } else {
769                 _ps.executeUpdate();
770            }
771            
772            session.getValueCache().remove(pk);
773        } catch (SQLException se) {
774            throw new PersistenceDatabaseException(se);
775        }
776        
777        session.removed(pk, false);
778    }
779    
780    @Override
781    public void remove(Collection<LanguagePK> pks)
782            throws PersistenceDatabaseException {
783        if(pks.size() > 0) {
784            PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
785            int _modifiedEntities = 0;
786            
787            try {
788                for(LanguagePK pk : pks) {
789                    long _entityId = pk.getEntityId();
790                    
791                    _ps.setLong(1, _entityId);
792                    
793                    _ps.addBatch();
794                    _modifiedEntities++;
795                }
796                
797                if(_modifiedEntities != 0) {
798                    if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
799                        int[] _counts = _ps.executeBatch();
800                        
801                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
802                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
803                                throw new PersistenceDatabaseUpdateException("batch remove failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
804                            }
805                        }
806                    } else {
807                        _ps.executeBatch();
808                    }
809                    
810                    _ps.clearBatch();
811                    
812                    pks.forEach((pk) -> {
813                        session.getValueCache().remove(pk);
814                    });
815                }
816            } catch (SQLException se) {
817                throw new PersistenceDatabaseException(se);
818            }
819            
820            pks.forEach((pk) -> {
821                session.removed(pk, true);
822            });
823        }
824    }
825    
826    @Override
827    public boolean validPK(LanguagePK pk)
828            throws PersistenceDatabaseException {
829        boolean valid = false;
830        PreparedStatement _ps = session.prepareStatement(SQL_VALID);
831        ResultSet _rs = null;
832        
833        try {
834            _ps.setLong(1, pk.getEntityId());
835            
836            _rs = _ps.executeQuery();
837            if(_rs.next()) {
838                long _count = _rs.getLong(1);
839                if(_rs.wasNull())
840                    _count = 0;
841                
842                if(_count == 1)
843                    valid = true;
844            }
845        } catch (SQLException se) {
846            throw new PersistenceDatabaseException(se);
847        } finally {
848            if(_rs != null) {
849                try {
850                    _rs.close();
851                } catch (SQLException se) {
852                    // do nothing
853                }
854            }
855        }
856        
857        return valid;
858    }
859    
860}