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