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