Source code

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