Source code

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