Source code

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