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