Source code

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