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