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