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