public CacheEntry findMostRecent(Connection con) { return con.createQuery("select id, revision, date from cache order by revision desc, date desc limit 1") .executeAndFetchFirst(CacheEntry.class); }
public void associateFileToArchive(Connection con, ArchiveEntry archive, int fileId, int nameHash) { if (associateFile == null) { associateFile = con.createQuery("insert into file (archive, fileId, nameHash) values (:archive, :fileId, :nameHash)"); } associateFile .addParameter("archive", archive.getId()) .addParameter("fileId", fileId) .addParameter("nameHash", nameHash) .executeUpdate(); } }
public List<IndexEntry> findIndexesForCache(Connection con, CacheEntry cache) { return con.createQuery("select id, indexId, crc, revision from `index` where cache = :cache") .addParameter("cache", cache.getId()) .executeAndFetch(IndexEntry.class); }
public CacheEntry createCache(Connection con, int revision, Instant date) { int cacheId = con.createQuery("insert into cache (revision, date) values (:revision, :date)") .addParameter("revision", revision) .addParameter("date", date) .executeUpdate() .getKey(int.class); CacheEntry entry = new CacheEntry(); entry.setId(cacheId); entry.setRevision(revision); entry.setDate(date); return entry; }
public ArchiveEntry findArchive(Connection con, IndexEntry index, int archiveId, int nameHash, int crc, int revision) { if (findArchive == null) { findArchive = con.createQuery("select distinct archive.id, archive.archiveId, archive.nameHash," + " archive.crc, archive.revision, archive.hash from archive " + " join index_archive on index_archive.archive = archive.id" + " join `index` on index.id = index_archive.index" + " where archive.archiveId = :archiveId" + " and archive.nameHash = :nameHash" + " and archive.crc = :crc" + " and archive.revision = :revision" + " and index.indexId = :indexId"); } ArchiveEntry entry = findArchive .addParameter("archiveId", archiveId) .addParameter("nameHash", nameHash) .addParameter("crc", crc) .addParameter("revision", revision) .addParameter("indexId", index.getIndexId()) .executeAndFetchFirst(ArchiveEntry.class); return entry; }
public ResultSetIterable<ArchiveEntry> findArchivesForIndex(Connection con, IndexEntry indexEntry) { return con.createQuery("select archive.id, archive.archiveId, archive.nameHash," + " archive.crc, archive.revision, archive.hash from index_archive " + "join archive on index_archive.archive = archive.id " + "where index_archive.index = :id") .addParameter("id", indexEntry.getId()) .executeAndFetchLazy(ArchiveEntry.class); }
private <T> ResultSetHandlerFactory<T> newResultSetHandlerFactory(Class<T> returnType) { final Quirks quirks = getConnection().getSql2o().getQuirks(); ResultSetHandlerFactoryBuilder builder = getResultSetHandlerFactoryBuilder(); if(builder==null) builder=new DefaultResultSetHandlerFactoryBuilder(); builder.setAutoDeriveColumnNames(this.autoDeriveColumnNames); builder.setCaseSensitive(this.caseSensitive); builder.setColumnMappings(this.getColumnMappings()); builder.setQuirks(quirks); builder.throwOnMappingError(this.throwOnMappingFailure); return builder.newFactory(returnType); }
@SuppressWarnings("unchecked") public <V> V runInTransaction(StatementRunnableWithResult<V> runnableWithResult, Object argument, int isolationLevel){ Connection connection = this.beginTransaction(isolationLevel); Object result; try{ result = runnableWithResult.run(connection, argument); } catch (Throwable throwable) { connection.rollback(); throw new Sql2oException("An error occurred while executing StatementRunnableWithResult. Transaction rolled back.", throwable); } connection.commit(); return (V)result; }
try (Connection con = sql2o.beginTransaction()) con.commit();
public Query createQueryWithParams(String queryText, Object... paramValues){ // due to #146, creating a query will not create a statement anymore; // the PreparedStatement will only be created once the query needs to be executed // => there is no need to handle the query closing here anymore since there is nothing to close return createQuery(queryText) .withParams(paramValues); }
public Query createQuery(String queryText, String ... columnNames) { try { if (jdbcConnection.isClosed()) { createConnection(); } } catch(SQLException e) { throw new Sql2oException("Error creating connection", e); } return new Query(this, queryText, columnNames); }
@Override public void setParameter(int paramIdx, PreparedStatement statement) throws SQLException { getConnection().getSql2o().getQuirks().setParameter(statement, paramIdx, value); } });
/************** private stuff ***************/ private void closeConnectionIfNecessary(){ try{ if (connection.autoClose){ connection.close(); } } catch (Exception ex){ throw new Sql2oException("Error while attempting to close connection", ex); } }
Connection(Sql2o sql2o, ConnectionSource connectionSource, boolean autoClose) { this.connectionSource = connectionSource != null ? connectionSource : sql2o.getConnectionSource(); this.autoClose = autoClose; this.sql2o = sql2o; createConnection(); }
public Iterator<T> iterator() { return new PojoResultSetIterator<>(rs, isCaseSensitive(), quirks, resultSetHandlerFactory); } };
public IndexEntry createIndex(Connection con, CacheEntry cache, int indexId, int crc, int revision) { int id = con.createQuery("insert into `index` (cache, indexId, crc, revision) values (:cache, :indexId, :crc, :revision)") .addParameter("cache", cache.getId()) .addParameter("indexId", indexId) .addParameter("crc", crc) .addParameter("revision", revision) .executeUpdate() .getKey(int.class); IndexEntry entry = new IndexEntry(); entry.setId(id); entry.setIndexId(indexId); entry.setCrc(crc); entry.setRevision(revision); return entry; }
public void associateArchiveToIndex(Connection con, ArchiveEntry archive, IndexEntry index) { if (associateArchive == null) { associateArchive = con.createQuery("insert into index_archive (`index`, archive) values (:index, :archive)"); } associateArchive .addParameter("index", index.getId()) .addParameter("archive", archive.getId()) .executeUpdate(); }
public Query createQuery(String queryText, boolean returnGeneratedKeys){ try { if (jdbcConnection.isClosed()){ createConnection(); } } catch (SQLException e) { throw new Sql2oException("Error creating connection", e); } return new Query(this, queryText, returnGeneratedKeys); }
public ArchiveEntry createArchive(Connection con, IndexEntry index, int archiveId, int nameHash, int crc, int revision, byte[] hash) { if (insertArchive == null) { insertArchive = con.createQuery("insert into archive (archiveId, nameHash, crc, revision, hash) values " + "(:archiveId, :nameHash, :crc, :revision, :hash)"); } int id = insertArchive .addParameter("archiveId", archiveId) .addParameter("nameHash", nameHash) .addParameter("crc", crc) .addParameter("revision", revision) .addParameter("hash", hash) .executeUpdate() .getKey(int.class); ArchiveEntry entry = new ArchiveEntry(); entry.setId(id); entry.setArchiveId(archiveId); entry.setNameHash(nameHash); entry.setCrc(crc); entry.setRevision(revision); entry.setHash(hash); return entry; }