| /* |
| * Copyright 2000-2012 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.intellij.openapi.vcs.changes.dbCommitted; |
| |
| import com.intellij.openapi.diagnostic.Logger; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.util.io.BufferExposingByteArrayOutputStream; |
| import com.intellij.openapi.util.io.FileUtil; |
| import com.intellij.openapi.util.text.StringUtil; |
| import com.intellij.openapi.vcs.*; |
| import com.intellij.openapi.vcs.changes.Change; |
| import com.intellij.openapi.vcs.changes.ContentRevision; |
| import com.intellij.openapi.vcs.changes.committed.ReceivedChangeList; |
| import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; |
| import com.intellij.util.ThrowableConsumer; |
| import com.intellij.util.ThrowableConvertor; |
| import com.intellij.util.ThrowableRunnable; |
| import com.intellij.util.containers.MultiMap; |
| import com.intellij.util.io.DataOutputStream; |
| import org.jetbrains.annotations.NotNull; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.DataInputStream; |
| import java.io.IOException; |
| import java.sql.*; |
| import java.util.*; |
| |
| /** |
| * Created with IntelliJ IDEA. |
| * User: Irina.Chernushina |
| * Date: 10/8/12 |
| * Time: 3:05 PM |
| */ |
| public class VcsSqliteLayer { |
| private final static int ourLastPathRevisionBatchSize = 10; |
| private final KnownRepositoryLocations myKnownRepositoryLocations; |
| private final CacheJdbcConnection myConnection; |
| private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vcs.changes.dbCommitted.VcsSqliteLayer"); |
| |
| public VcsSqliteLayer(final Project project, KnownRepositoryLocations locations) { |
| myKnownRepositoryLocations = locations; |
| myConnection = new CacheJdbcConnection(DbSettings.getDbFilePath(project), |
| new ThrowableConsumer<Connection, VcsException>() { |
| @Override |
| public void consume(Connection connection) throws VcsException { |
| initDb(connection); |
| } |
| }); |
| } |
| |
| private void initDb(Connection connection) throws VcsException { |
| try { |
| connection.createStatement().execute(createStatementForTable(SqliteTables.KNOWN_VCS)); |
| connection.createStatement().execute(createStatementForTable(SqliteTables.ROOT)); |
| connection.createStatement().execute(createStatementForTable(SqliteTables.AUTHOR)); |
| connection.createStatement().execute(createStatementForTable(SqliteTables.REVISION)); |
| connection.createStatement().execute(createStatementForTable(SqliteTables.PATHS)); |
| connection.createStatement().execute(createStatementForTable(SqliteTables.PATHS_2_REVS)); |
| connection.createStatement().execute(createStatementForTable(SqliteTables.INCOMING_PATHS)); |
| |
| connection.createStatement().execute("CREATE INDEX " + SqliteTables.IDX_ROOT_URL + " ON ROOT (URL)"); |
| connection.createStatement().execute("CREATE INDEX " + "VCS_FK" + " ON ROOT (VCS_FK)"); |
| connection.createStatement().execute("CREATE INDEX " + SqliteTables.IDX_AUTHOR_NAME + " ON AUTHOR (NAME)"); |
| connection.createStatement().execute("CREATE INDEX " + SqliteTables.IDX_REVISION_DATE + " ON REVISION (DATE)"); |
| connection.createStatement().execute("CREATE INDEX " + SqliteTables.IDX_REVISION_NUMBER_INT + " ON REVISION (NUMBER_INT)"); |
| connection.createStatement().execute("CREATE INDEX " + SqliteTables.IDX_PATHS_PATH + " ON PATHS (PATH)"); |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| public void checkVcsRootsAreTracked(final MultiMap<String, String> vcses) throws VcsException { |
| if (vcses.isEmpty()) return; |
| |
| final MultiMap<String, String> copy = new MultiMap<String, String>(); |
| copy.putAllValues(vcses); |
| if (! checkForInMemory(copy)) return; |
| |
| final HashSet<String> vcsNamesSet = new HashSet<String>(vcses.keySet()); |
| for (Iterator<String> iterator = vcsNamesSet.iterator(); iterator.hasNext(); ) { |
| final String key = iterator.next(); |
| if (myKnownRepositoryLocations.exists(key)) { |
| iterator.remove(); |
| } |
| } |
| |
| if (! vcsNamesSet.isEmpty()) { |
| ensureVcsAreInDB(vcsNamesSet); |
| } |
| |
| final Set<Long> rootIdsToCheck = ensurePathsAreInDB(copy); |
| if (! rootIdsToCheck.isEmpty()) { |
| updateLastRevisions(rootIdsToCheck); |
| } |
| } |
| |
| private void updateLastRevisions(Set<Long> rootIdsToCheck) throws VcsException { |
| final PreparedStatement maxStatement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_SELECT_MAX_REVISION, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| final String num = SqliteTables.REVISION.NUMBER_INT; |
| return connection.prepareStatement( |
| "SELECT " + num + "MAX_REV, " + SqliteTables.REVISION.DATE + "MAX_DATE FROM " + SqliteTables.REVISION.TABLE_NAME + |
| " WHERE MAX_REV=(" + " SELECT MAX(" + num + ") FROM " + SqliteTables.REVISION.TABLE_NAME + |
| " WHERE " + SqliteTables.REVISION.ROOT_FK + " =?"); |
| } |
| }); |
| final PreparedStatement minStatement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_SELECT_MIN_REVISION, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| final String num = SqliteTables.REVISION.NUMBER_INT; |
| return connection.prepareStatement( |
| "SELECT " + num + "MIN_REV, " + SqliteTables.REVISION.DATE + "MIN_DATE FROM " + SqliteTables.REVISION.TABLE_NAME + |
| " WHERE MIN_REV=(" + " SELECT MIN(" + num + ") FROM " + SqliteTables.REVISION.TABLE_NAME + |
| " WHERE " + SqliteTables.REVISION.ROOT_FK + " =?"); |
| } |
| }); |
| |
| try { |
| for (final Long id : rootIdsToCheck) { |
| maxStatement.setLong(1, id); |
| final ResultSet set = maxStatement.executeQuery(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long max = set.getLong(1); |
| final long time = set.getLong(2); |
| if (max > 0) {// 0 is === SQL NULL |
| myKnownRepositoryLocations.setLastRevision(id, new RevisionId(max, time)); |
| } |
| } |
| }); |
| |
| minStatement.setLong(1, id); |
| final ResultSet setMin = minStatement.executeQuery(); |
| SqliteUtil.readSelectResults(setMin, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long min = setMin.getLong(1); |
| final long time = setMin.getLong(2); |
| if (min > 0) {// 0 is === SQL NULL |
| myKnownRepositoryLocations.setFirstRevision(id, new RevisionId(min, time)); |
| } |
| } |
| }); |
| } |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| private Set<Long> ensurePathsAreInDB(final MultiMap<String, String> copy) throws VcsException { |
| final Set<Long> idsToCheck = new HashSet<Long>(); |
| final PreparedStatement select = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_SELECT_ROOTS, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("SELECT * FROM " + SqliteTables.ROOT.TABLE_NAME + " WHERE VCS_FK=?"); |
| } |
| }); |
| |
| try { |
| for (final String vcsName : copy.keySet()) { |
| select.setLong(1, myKnownRepositoryLocations.getVcsKey(vcsName)); |
| final ResultSet set = select.executeQuery(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long id = set.getLong(SqliteTables.ROOT.ID); |
| final String url = set.getString(SqliteTables.ROOT.URL); |
| myKnownRepositoryLocations.add(vcsName, url, id); |
| copy.remove(vcsName, url); |
| if (myKnownRepositoryLocations.getLastRevision(id) == null) { |
| idsToCheck.add(id); |
| } |
| } |
| }); |
| } |
| |
| if (copy.isEmpty()) return idsToCheck; |
| |
| final PreparedStatement insert = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_ROOT, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("INSERT INTO " + SqliteTables.ROOT.TABLE_NAME + " ( " + |
| SqliteTables.ROOT.VCS_FK + ", " + SqliteTables.ROOT.URL + ") VALUES (?,?)", Statement.RETURN_GENERATED_KEYS); |
| } |
| }); |
| for (String vcsName : copy.keySet()) { |
| insert.setLong(1, myKnownRepositoryLocations.getVcsKey(vcsName)); |
| for (String path : copy.get(vcsName)) { |
| insert.setString(2, path); |
| final long id = SqliteUtil.insert(insert); |
| myKnownRepositoryLocations.add(vcsName, path, id); |
| } |
| } |
| myConnection.commit(); |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| return idsToCheck; |
| } |
| |
| private void ensureVcsAreInDB(final HashSet<String> vcsNamesSet) throws VcsException { |
| final PreparedStatement readVcses = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_SELECT_VCS, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection o) throws SQLException { |
| return o.prepareStatement("SELECT * FROM VCS"); |
| } |
| }); |
| try { |
| final ResultSet set = readVcses.executeQuery(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long id = set.getLong(SqliteTables.KNOWN_VCS.ID); |
| final String name = set.getString(SqliteTables.KNOWN_VCS.NAME); |
| myKnownRepositoryLocations.addVcs(name, id); |
| vcsNamesSet.remove(name); |
| } |
| }); |
| |
| if (vcsNamesSet.isEmpty()) return; |
| |
| final PreparedStatement insertStatement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_VCS, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection o) throws SQLException { |
| return o.prepareStatement("INSERT INTO " + SqliteTables.KNOWN_VCS.TABLE_NAME + " (" + SqliteTables.KNOWN_VCS.NAME + |
| ") VALUES (?)", Statement.RETURN_GENERATED_KEYS); |
| } |
| }); |
| for (String name : vcsNamesSet) { |
| insertStatement.setString(1, name); |
| final long id = SqliteUtil.insert(insertStatement); |
| myKnownRepositoryLocations.addVcs(name, id); |
| } |
| myConnection.commit(); |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| private boolean checkForInMemory(MultiMap<String, String> map) { |
| for (String vcsName : map.keySet()) { |
| final Collection<String> paths = map.get(vcsName); |
| for (Iterator<String> iterator = paths.iterator(); iterator.hasNext(); ) { |
| final String path = iterator.next(); |
| if (myKnownRepositoryLocations.exists(vcsName, path)) { |
| iterator.remove(); |
| } |
| } |
| } |
| for (String paths : map.values()) { |
| if (! paths.isEmpty()) return true; |
| } |
| return false; |
| } |
| |
| private static String createStatementForTable(SqliteTables.BaseTable baseTable) { |
| return "CREATE TABLE " + baseTable.TABLE_NAME + " ( ID INTEGER PRIMARY KEY, " + baseTable.getCreateTableStatement() + ");"; |
| } |
| |
| public void appendLists(final AbstractVcs vcs, final String root, final List<CommittedChangeList> lists) throws VcsException { |
| //authors, revisions, paths |
| if (lists.isEmpty()) return; |
| assert myKnownRepositoryLocations.exists(vcs.getName(), root); |
| final long locationId = myKnownRepositoryLocations.getLocationId(vcs.getName(), root); |
| |
| long maxRev = -1; |
| long minRev = Long.MAX_VALUE; |
| long maxTime = -1; |
| long minTime = -1; |
| final RevisionId firstRevData = myKnownRepositoryLocations.getFirstRevision(locationId); |
| final Long firstRevision = firstRevData == null ? null : firstRevData.getNumber(); |
| final RevisionId lastRevData = myKnownRepositoryLocations.getLastRevision(locationId); |
| final Long lastRevision = lastRevData == null ? null : lastRevData.getNumber(); |
| |
| final List<List<CommittedChangeList>> split = new CollectionSplitter<CommittedChangeList>(20).split(lists); |
| final Map<String, Long> knowPaths = new HashMap<String, Long>(); |
| for (List<CommittedChangeList> changeLists : split) { |
| final Set<String> names = new HashSet<String>(); |
| final Set<String> paths = new HashSet<String>(); |
| for (Iterator<CommittedChangeList> iterator = changeLists.iterator(); iterator.hasNext(); ) { |
| final CommittedChangeList list = iterator.next(); |
| final long number = list.getNumber(); |
| if (lastRevision != null && number <= lastRevision && number >= firstRevision) { |
| iterator.remove(); |
| continue; |
| } |
| |
| if (number > maxRev) { |
| maxRev = number; |
| maxTime = list.getCommitDate().getTime(); |
| } |
| if (number < minRev) { |
| minRev = number; |
| minTime = list.getCommitDate().getTime(); |
| } |
| |
| names.add(list.getCommitterName()); // todo if null. also comment |
| for (Change change : list.getChangesWithMovedTrees()) { |
| if (change.getBeforeRevision() != null) { |
| paths.add(getPath(change.getBeforeRevision())); |
| } |
| if (change.getAfterRevision() != null) { |
| paths.add(getPath(change.getAfterRevision())); |
| } |
| } |
| } |
| final Map<String, Long> knownAuthors = myKnownRepositoryLocations.filterKnownAuthors(names); |
| checkAndAddAuthors(names, knownAuthors); |
| checkAndAddPaths(paths, knowPaths, locationId); |
| insertChangeListsIfNotExists(vcs, knownAuthors, changeLists, locationId, knowPaths); |
| |
| if (firstRevision == null || minRev < firstRevision) { |
| myKnownRepositoryLocations.setFirstRevision(locationId, new RevisionId(minRev, minTime)); |
| } |
| if (lastRevision == null || maxRev > lastRevision) { |
| myKnownRepositoryLocations.setLastRevision(locationId, new RevisionId(maxRev, maxTime)); |
| } |
| } |
| } |
| |
| private String getPath(ContentRevision revision) { |
| final String path = FileUtil.toSystemIndependentName(revision.getFile().getPath()); |
| return path.endsWith("/") ? path : path + "/"; |
| } |
| |
| private Map<Long, CommittedChangeList> insertChangeListsIfNotExists(AbstractVcs vcs, final Map<String, Long> authors, |
| final List<CommittedChangeList> lists, |
| final long locationId, Map<String, Long> knowPaths) |
| throws VcsException { |
| final PreparedStatement statement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_REVISION, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("INSERT INTO " + SqliteTables.REVISION.TABLE_NAME + " ( " + |
| StringUtil.join(Arrays.asList(SqliteTables.REVISION.ROOT_FK, SqliteTables.REVISION.AUTHOR_FK, SqliteTables.REVISION.DATE, |
| SqliteTables.REVISION.NUMBER_INT, SqliteTables.REVISION.NUMBER_STR, SqliteTables.REVISION.COMMENT, SqliteTables.REVISION.COUNT, SqliteTables.REVISION.RAW_DATA), ", ") + |
| ") VALUES (?,?,?,?,?,?,?,?)", Statement.RETURN_GENERATED_KEYS); |
| } |
| }); |
| final Map<Long, CommittedChangeList> result = new HashMap<Long, CommittedChangeList>(); |
| final CachingCommittedChangesProvider provider = (CachingCommittedChangesProvider)vcs.getCommittedChangesProvider(); |
| try { |
| statement.setLong(1, locationId); |
| |
| for (CommittedChangeList list : lists) { |
| statement.setLong(2, authors.get(list.getCommitterName())); |
| statement.setLong(3, list.getCommitDate().getTime()); |
| statement.setLong(4, list.getNumber()); |
| statement.setString(5, String.valueOf(list.getNumber())); |
| statement.setString(6, list.getComment()); |
| statement.setLong(7, list.getChanges().size()); |
| final BufferExposingByteArrayOutputStream stream = new BufferExposingByteArrayOutputStream(); |
| provider.writeChangeList(new DataOutputStream(stream), list); |
| statement.setBytes(8, stream.toByteArray()); |
| final long id = SqliteUtil.insert(statement); |
| result.put(id, list); |
| |
| insertPathsChanges(knowPaths, list, id); |
| } |
| myConnection.commit(); |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| catch (IOException e) { |
| throw new VcsException(e); |
| } |
| return result; |
| } |
| |
| private void insertPathsChanges(Map<String, Long> paths, CommittedChangeList list, long listId) throws VcsException { |
| final PreparedStatement insert = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_PATH_2_REVS, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("INSERT INTO " + SqliteTables.PATHS_2_REVS.TABLE_NAME + |
| " ( " + StringUtil.join(Arrays.asList(SqliteTables.PATHS_2_REVS.PATH_FK, SqliteTables.PATHS_2_REVS.REVISION_FK, |
| SqliteTables.PATHS_2_REVS.TYPE, SqliteTables.PATHS_2_REVS.COPY_PATH_ID, SqliteTables.PATHS_2_REVS.DELETE_PATH_ID, |
| SqliteTables.PATHS_2_REVS.VISIBLE), " , ") + |
| ") VALUES (?,?,?,?,?,?)", Statement.RETURN_GENERATED_KEYS); |
| } |
| }); |
| try { |
| insert.setLong(2, listId); |
| final Collection<Change> withMoved = list.getChangesWithMovedTrees(); |
| final Set<Change> simple = new HashSet<Change>(list.getChanges()); |
| for (Change change : withMoved) { |
| insertOneChange(paths, insert, change, simple.contains(change)); |
| } |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| private void insertOneChange(Map<String, Long> paths, PreparedStatement insert, Change change, final boolean visible) throws SQLException { |
| insert.setLong(6, visible ? 1 : 0); |
| final ChangeTypeEnum type = ChangeTypeEnum.getChangeType(change); |
| if (change.getBeforeRevision() == null) { |
| // added, one path |
| insert.setLong(1, paths.get(getPath(change.getAfterRevision()))); |
| insert.setLong(3, type.getCode()); |
| SqliteUtil.insert(insert); |
| } else if (ChangeTypeEnum.MOVE.equals(type)) { |
| // 2 paths |
| final Long beforeId = paths.get(getPath(change.getBeforeRevision())); |
| insert.setLong(1, beforeId); |
| insert.setLong(3, ChangeTypeEnum.DELETE.getCode()); |
| SqliteUtil.insert(insert); |
| |
| insert.setLong(1, paths.get(getPath(change.getAfterRevision()))); |
| insert.setLong(4, beforeId); |
| insert.setLong(3, type.getCode()); |
| SqliteUtil.insert(insert); |
| } else if (change.getAfterRevision() == null) { |
| insert.setLong(1, paths.get(getPath(change.getBeforeRevision()))); |
| insert.setLong(3, type.getCode()); |
| SqliteUtil.insert(insert); |
| } else { |
| // only after |
| insert.setLong(1, paths.get(getPath(change.getAfterRevision()))); |
| insert.setLong(3, type.getCode()); |
| SqliteUtil.insert(insert); |
| } |
| } |
| |
| private void checkAndAddPaths(final Set<String> paths, final Map<String, Long> known, final Long locationId) throws VcsException { |
| final PreparedStatement select = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_READ_PATH, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("SELECT " + SqliteTables.PATHS.ID + " FROM " + SqliteTables.PATHS.TABLE_NAME + |
| " WHERE " + SqliteTables.PATHS.ROOT_FK + " = ? AND " + SqliteTables.PATHS.PATH + " = ?"); |
| } |
| }); |
| try { |
| select.setLong(1, locationId); |
| for (final String path : paths) { |
| select.setString(2, path); |
| final ResultSet set = select.executeQuery(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| known.put(path, set.getLong(1)); |
| } |
| }); |
| } |
| |
| paths.removeAll(known.keySet()); |
| if (paths.isEmpty()) return; |
| |
| final PreparedStatement insert = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_PATH, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("INSERT INTO " + SqliteTables.PATHS.TABLE_NAME + " ( " + |
| SqliteTables.PATHS.ROOT_FK + " , " + SqliteTables.PATHS.PATH + " ) VALUES (?,?)", Statement.RETURN_GENERATED_KEYS); |
| } |
| }); |
| insert.setLong(1, locationId); |
| for (String path : paths) { |
| insert.setString(2, path); |
| final long id = SqliteUtil.insert(insert); |
| known.put(path, id); |
| } |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| private void checkAndAddAuthors(final Set<String> names, final Map<String, Long> known) throws VcsException { |
| final PreparedStatement statement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_FILTER_KNOWN_AUTHORS, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("SELECT " + SqliteTables.AUTHOR.ID + ", " + SqliteTables.AUTHOR.NAME + |
| " FROM " + SqliteTables.AUTHOR.TABLE_NAME + " WHERE " + SqliteTables.AUTHOR.NAME + "=?"); |
| } |
| }); |
| |
| try { |
| for (final Iterator<String> iterator = names.iterator(); iterator.hasNext(); ) { |
| final String name = iterator.next(); |
| statement.setString(1, name); |
| final ResultSet set = statement.executeQuery(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long id = set.getLong(SqliteTables.AUTHOR.ID); |
| myKnownRepositoryLocations.addKnownAuthor(name, id); |
| known.put(name, id); |
| iterator.remove(); |
| } |
| }); |
| } |
| if (names.isEmpty()) return; |
| |
| final PreparedStatement insertAuthor = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_ADD_AUTHOR, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("INSERT INTO " + SqliteTables.AUTHOR.TABLE_NAME + " ( " + SqliteTables.AUTHOR.NAME + |
| ") VALUES (?)", Statement.RETURN_GENERATED_KEYS); |
| } |
| }); |
| for (String name : names) { |
| insertAuthor.setString(1, name); |
| final long id = SqliteUtil.insert(insertAuthor); |
| myKnownRepositoryLocations.addKnownAuthor(name, id); |
| known.put(name, id); |
| } |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| @NotNull |
| public RevisionId getFirstRevision(final AbstractVcs vcs, final String root) { |
| final String systemIndependent = FileUtil.toSystemIndependentName(root); |
| if (! myKnownRepositoryLocations.exists(vcs.getName(), systemIndependent)) { |
| return RevisionId.FAKE; |
| } |
| final long locationId = myKnownRepositoryLocations.getLocationId(vcs.getName(), systemIndependent); |
| return myKnownRepositoryLocations.getFirstRevision(locationId); |
| } |
| |
| @NotNull |
| public RevisionId getLastRevision(final AbstractVcs vcs, final String root) { |
| final String systemIndependent = FileUtil.toSystemIndependentName(root); |
| if (! myKnownRepositoryLocations.exists(vcs.getName(), systemIndependent)) { |
| return RevisionId.FAKE; |
| } |
| final long locationId = myKnownRepositoryLocations.getLocationId(vcs.getName(), systemIndependent); |
| return myKnownRepositoryLocations.getLastRevision(locationId); |
| } |
| |
| // alternatively, we can use usual lists + a map marking incoming |
| public List<ReceivedChangeList> selectIncoming(final AbstractVcs vcs, final RepositoryLocation location) throws VcsException { |
| final Map<Long, CommittedChangeList> full = new HashMap<Long, CommittedChangeList>(); |
| final TreeMap<Long, Set<String>> incomingPaths = new TreeMap<Long, Set<String>>(); |
| final long locationId = getLocationId(vcs, location); |
| |
| final PreparedStatement select = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_SELECT_INCOMING, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| // todo control what is selected |
| return connection.prepareStatement("SELECT R." + SqliteTables.REVISION.NUMBER_INT + " , R." + SqliteTables.REVISION.RAW_DATA + |
| " , P." + SqliteTables.PATHS.PATH + |
| " FROM " + SqliteTables.INCOMING_PATHS.TABLE_NAME + "I INNER JOIN " + |
| SqliteTables.PATHS_2_REVS.TABLE_NAME + "PR ON I." + SqliteTables.INCOMING_PATHS.PR_FK + " = PR." + |
| SqliteTables.PATHS_2_REVS.ID + ", " + SqliteTables.REVISION.TABLE_NAME + " R ON PR." + SqliteTables.PATHS_2_REVS.REVISION_FK + |
| " = R." + SqliteTables.REVISION.ID + " , " + SqliteTables.PATHS_2_REVS.TABLE_NAME + "P ON PR." + SqliteTables.PATHS_2_REVS.PATH_FK + |
| " = P." + SqliteTables.PATHS.ID + " WHERE R." + SqliteTables.REVISION.ROOT_FK + "=?"); |
| } |
| }); |
| final CachingCommittedChangesProvider provider = vcs.getCachingCommittedChangesProvider(); |
| try { |
| select.setLong(1, locationId); |
| final ResultSet set = select.executeQuery(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long revNum = set.getLong("R." + SqliteTables.REVISION.NUMBER_INT); |
| Set<String> paths = incomingPaths.get(revNum); |
| if (paths == null) { |
| final byte[] bytes = set.getBytes("R." + SqliteTables.REVISION.RAW_DATA); |
| final CommittedChangeList nativeList = readListByProvider(bytes, provider, location); |
| full.put(revNum, nativeList); |
| paths = new HashSet<String>(); |
| incomingPaths.put(revNum, paths); |
| } |
| final String path = set.getString("P." + SqliteTables.PATHS.PATH); |
| paths.add(path); |
| } |
| }); |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| final List<ReceivedChangeList> result = new ArrayList<ReceivedChangeList>(); |
| for (Map.Entry<Long, Set<String>> entry : incomingPaths.entrySet()) { |
| final Long revNum = entry.getKey(); |
| |
| } |
| // TODO continue here |
| // TODO continue here |
| // TODO continue here |
| // TODO continue here |
| // TODO continue here |
| |
| return null; |
| // return new ArrayList<ReceivedChangeList>(incomingPaths.descendingMap().values()); |
| } |
| |
| private long getLocationId(AbstractVcs vcs, RepositoryLocation location) { |
| final String normalizedLocation = normalizeLocation(location); |
| if (! myKnownRepositoryLocations.exists(vcs.getName(), normalizedLocation)) { |
| assert false; |
| } |
| return myKnownRepositoryLocations.getLocationId(vcs.getName(), normalizedLocation); |
| } |
| |
| public void insertIncoming(final AbstractVcs vcs, final RepositoryLocation location, long pathId, final long lastRev, final long oldRev) |
| throws VcsException { |
| assert lastRev > 0 || oldRev > 0; |
| final long locationId = getLocationId(vcs, location); |
| |
| if (lastRev > 0 && oldRev > 0) { |
| final PreparedStatement insertBoth = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_INCOMING, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("INSERT INTO " + SqliteTables.INCOMING_PATHS.TABLE_NAME + |
| " ( " + SqliteTables.INCOMING_PATHS.PR_FK + " ) VALUES (SELECT " + SqliteTables.PATHS_2_REVS.ID + " FROM " + |
| SqliteTables.PATHS_2_REVS.TABLE_NAME + "PR INNER JOIN " + SqliteTables.REVISION.TABLE_NAME + " R ON R." + |
| SqliteTables.REVISION.ID + "=PR." + SqliteTables.PATHS_2_REVS.REVISION_FK + " WHERE R." + |
| SqliteTables.REVISION.NUMBER_INT + "<=? AND R." + SqliteTables.REVISION.NUMBER_INT + ">=? AND R." + SqliteTables.REVISION.ROOT_FK + |
| "=? AND PR." + SqliteTables.PATHS_2_REVS.PATH_FK + "=?)"); |
| } |
| }); |
| try { |
| insertBoth.setLong(1, lastRev); |
| insertBoth.setLong(2, oldRev); |
| insertBoth.setLong(3, locationId); |
| insertBoth.setLong(4, pathId); |
| final int numRows = insertBoth.executeUpdate(); |
| return; |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| if (lastRev > 0) { |
| final PreparedStatement insertOnlyLast = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_INCOMING, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("INSERT INTO " + SqliteTables.INCOMING_PATHS.TABLE_NAME + |
| " ( " + SqliteTables.INCOMING_PATHS.PR_FK + " ) VALUES (SELECT " + SqliteTables.PATHS_2_REVS.ID + " FROM " + |
| SqliteTables.PATHS_2_REVS.TABLE_NAME + "PR INNER JOIN " + SqliteTables.REVISION.TABLE_NAME + " R ON R." + |
| SqliteTables.REVISION.ID + "=PR." + SqliteTables.PATHS_2_REVS.REVISION_FK + " WHERE R." + |
| SqliteTables.REVISION.NUMBER_INT + "<=? AND R." + SqliteTables.REVISION.ROOT_FK + |
| "=? AND PR." + SqliteTables.PATHS_2_REVS.PATH_FK + "=?)"); |
| } |
| }); |
| try { |
| insertOnlyLast.setLong(1, lastRev); |
| insertOnlyLast.setLong(2, locationId); |
| insertOnlyLast.setLong(3, pathId); |
| final int numRows = insertOnlyLast.executeUpdate(); |
| return; |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| // first rev > 0 |
| final PreparedStatement insertOnlyFirst = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_INCOMING, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("INSERT INTO " + SqliteTables.INCOMING_PATHS.TABLE_NAME + |
| " ( " + SqliteTables.INCOMING_PATHS.PR_FK + " ) VALUES (SELECT " + SqliteTables.PATHS_2_REVS.ID + " FROM " + |
| SqliteTables.PATHS_2_REVS.TABLE_NAME + "PR INNER JOIN " + SqliteTables.REVISION.TABLE_NAME + " R ON R." + |
| SqliteTables.REVISION.ID + "=PR." + SqliteTables.PATHS_2_REVS.REVISION_FK + " WHERE R." + SqliteTables.REVISION.NUMBER_INT + |
| ">=? AND R." + SqliteTables.REVISION.ROOT_FK + |
| "=? AND PR." + SqliteTables.PATHS_2_REVS.PATH_FK + "=?)"); |
| } |
| }); |
| try { |
| insertOnlyFirst.setLong(1, oldRev); |
| insertOnlyFirst.setLong(2, locationId); |
| insertOnlyFirst.setLong(3, pathId); |
| final int numRows = insertOnlyFirst.executeUpdate(); |
| return; |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| public List<CommittedChangeList> readLists(final AbstractVcs vcs, final RepositoryLocation location, |
| final RevisionId last, final RevisionId old, final String subfolder) throws VcsException { |
| final String root = normalizeLocation(location); |
| final RevisionId lastExisitngData = getLastRevision(vcs, root); |
| final RevisionId firstExistingData = getFirstRevision(vcs, root); |
| |
| if (lastExisitngData.isFake() || firstExistingData.isFake()) return Collections.emptyList(); |
| |
| final SelectListsQueryHelper helper = |
| new SelectListsQueryHelper(myConnection, lastExisitngData, firstExistingData, last, old, getLocationId(vcs, location), subfolder); |
| final List<CommittedChangeList> result = new ArrayList<CommittedChangeList>(); |
| try { |
| final PreparedStatement statement = helper.createStatement(); |
| final CachingCommittedChangesProvider provider = (CachingCommittedChangesProvider)vcs.getCommittedChangesProvider(); |
| final ResultSet set = statement.executeQuery(); |
| final Set<Long> controlSet = new HashSet<Long>(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long number = set.getLong(SqliteTables.REVISION.NUMBER_INT); |
| if (controlSet.contains(number)) { |
| return; |
| } |
| controlSet.add(number); |
| final byte[] bytes = set.getBytes(SqliteTables.REVISION.RAW_DATA); |
| final CommittedChangeList list = readListByProvider(bytes, provider, location); |
| result.add(list); |
| } |
| }); |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| |
| return result; |
| } |
| |
| public List<CommittedChangeList> readLists(final AbstractVcs vcs, final RepositoryLocation location, final long lastRev, final long oldRev) |
| throws VcsException { |
| final String root = normalizeLocation(location); |
| final long lastExisting = getLastRevision(vcs, root).getNumber(); |
| final long firstExisting = getFirstRevision(vcs, root).getNumber(); |
| |
| if (lastExisting == -1 || firstExisting == -1) return Collections.emptyList(); |
| final long operatingFirst = oldRev == -1 ? firstExisting : oldRev; |
| final long operatingLast = lastRev == -1 ? lastExisting : lastRev; |
| |
| final PreparedStatement statement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_SELECT_REVISIONS, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| // "real" statement - will be used when each committed changes provider will have the method to restore revision uniformly, through changed paths + # |
| // maybe it's safier to call left outer join, but for current VCSes we always have at least one path changed for each revision -> inner join is preferable |
| /*return connection.prepareStatement("SELECT * FROM " + SqliteTables.REVISION.TABLE_NAME + "R , " + |
| SqliteTables.PATHS + "P , "+ SqliteTables.AUTHOR + "A INNER JOIN " + SqliteTables.PATHS_2_REVS + "PR ON PR." + |
| SqliteTables.PATHS_2_REVS.REVISION_FK + "=R." + SqliteTables.REVISION.ID + " AND PR." + SqliteTables.PATHS_2_REVS.PATH_FK + |
| "=" + SqliteTables.PATHS.ID + " AND R." + SqliteTables.REVISION.AUTHOR_FK + "=A." + SqliteTables.AUTHOR.ID + |
| " WHERE R." + SqliteTables.REVISION.NUMBER_INT + ">=? AND R." + SqliteTables.REVISION.NUMBER_INT + "<=?");*/ |
| //1=first, 2=last |
| |
| return connection.prepareStatement("SELECT * FROM " + SqliteTables.REVISION.TABLE_NAME + " WHERE " + |
| SqliteTables.REVISION.NUMBER_INT + ">=? AND " + SqliteTables.REVISION.NUMBER_INT + "<=? ORDER BY " + SqliteTables.REVISION.NUMBER_INT |
| + " DESC"); |
| } |
| }); |
| final List<CommittedChangeList> result = new ArrayList<CommittedChangeList>(); |
| try { |
| |
| statement.setLong(1, operatingFirst); |
| statement.setLong(2, operatingLast); |
| final CachingCommittedChangesProvider provider = (CachingCommittedChangesProvider)vcs.getCommittedChangesProvider(); |
| final ResultSet set = statement.executeQuery(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final byte[] bytes = set.getBytes(SqliteTables.REVISION.RAW_DATA); |
| final CommittedChangeList list = readListByProvider(bytes, provider, location); |
| result.add(list); |
| |
| /*final long revisionId = set.getLong("R." + SqliteTables.REVISION.ID); |
| CommittedChangeList list = lists.get(revisionId); |
| if (list == null) { |
| final long numberLong = set.getLong("R." + SqliteTables.REVISION.NUMBER_INT); |
| final String numberStr = set.getString("R." + SqliteTables.REVISION.NUMBER_STR); |
| final String comment = set.getString("R." + SqliteTables.REVISION.COMMENT); |
| final Long date = set.getLong("R." + SqliteTables.REVISION.DATE); |
| final String author = set.getString("A." + SqliteTables.REVISION.AUTHOR_FK); |
| list = new CommittedChangeListImpl("", comment, author, numberLong, new Date(date), Collections.<Change>emptyList()); |
| }*/ |
| } |
| }); |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| return result; |
| } |
| |
| private CommittedChangeList readListByProvider(byte[] bytes, CachingCommittedChangesProvider provider, RepositoryLocation location) |
| throws SQLException { |
| final CommittedChangeList list; |
| try { |
| list = provider.readChangeList(location, new DataInputStream(new ByteArrayInputStream(bytes))); |
| } |
| catch (IOException e) { |
| throw new SQLException(e); |
| } |
| return list; |
| } |
| |
| public PathState getPathState(final AbstractVcs vcs, final RepositoryLocation location, final String path) throws VcsException { |
| String normalizedPath = FileUtil.toSystemIndependentName(path); |
| normalizedPath = normalizedPath.endsWith("/") ? normalizedPath : normalizedPath + "/"; |
| final String normalizedLocation = normalizeLocation(location); |
| if (! myKnownRepositoryLocations.exists(vcs.getName(), normalizedLocation)) return null; |
| |
| final PreparedStatement maxStatement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_SELECT_PATH_DATA, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) |
| throws SQLException { |
| final String innerQuery = "SELECT MAX(R." + |
| SqliteTables.REVISION.NUMBER_INT + |
| ") MAX FROM " + |
| SqliteTables.PATHS_2_REVS.TABLE_NAME + |
| " PR INNER JOIN " + |
| SqliteTables.REVISION.TABLE_NAME + |
| " R, " + |
| SqliteTables.PATHS.TABLE_NAME + |
| " P ON PR." + |
| SqliteTables.PATHS_2_REVS.REVISION_FK + |
| "=R." + |
| SqliteTables.REVISION.ID + |
| " AND PR." + |
| SqliteTables.PATHS_2_REVS.PATH_FK + |
| "=P." + |
| SqliteTables.PATHS.ID + |
| " WHERE P." + |
| SqliteTables.PATHS.PATH + |
| "=? AND R." + |
| SqliteTables.REVISION.ROOT_FK + |
| "=?"; |
| |
| return connection.prepareStatement("SELECT R." + |
| SqliteTables.REVISION.NUMBER_INT + |
| " REV_NU, PR." + |
| SqliteTables.PATHS_2_REVS.TYPE + |
| " TYPE FROM " + |
| SqliteTables.PATHS_2_REVS.TABLE_NAME + |
| " PR INNER JOIN " + |
| SqliteTables.REVISION.TABLE_NAME + |
| " R, " + |
| SqliteTables.PATHS.TABLE_NAME + |
| " P ON PR." + |
| SqliteTables.PATHS_2_REVS.REVISION_FK + |
| "=R." + |
| SqliteTables.REVISION.ID + |
| " AND PR." + |
| SqliteTables.PATHS_2_REVS.PATH_FK + |
| "=P." + |
| SqliteTables.PATHS.ID + |
| " WHERE P." + |
| SqliteTables.PATHS.PATH + |
| "=? AND R." + |
| SqliteTables.REVISION.ROOT_FK + |
| "=? AND R." + |
| SqliteTables.REVISION.NUMBER_INT + |
| " = (" + |
| innerQuery + |
| ")"); |
| } |
| }); |
| |
| try { |
| maxStatement.setString(1, normalizedPath); |
| maxStatement.setString(3, normalizedPath); |
| final long locationId = myKnownRepositoryLocations.getLocationId(vcs.getName(), normalizedLocation); |
| maxStatement.setLong(2, locationId); |
| maxStatement.setLong(4, locationId); |
| final long type[] = new long[1]; |
| final long maxRev[] = new long[1]; |
| maxRev[0] = -1; |
| final ResultSet set = maxStatement.executeQuery(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| maxRev[0] = set.getLong("REV_NU"); |
| type[0] = set.getLong("TYPE"); |
| } |
| }); |
| |
| if (maxRev[0] <= 0) return null; |
| if (type[0] == -100) return null; |
| final ChangeTypeEnum changeType = ChangeTypeEnum.getChangeType(type[0]); |
| if (changeType == null) return null; |
| return new PathState(maxRev[0], ! ChangeTypeEnum.DELETE.equals(changeType)); |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| } |
| |
| private String normalizeLocation(RepositoryLocation location) { |
| return FileUtil.toSystemIndependentName(location.toPresentableString()); |
| } |
| |
| // this is batch one |
| /*public <T> void getLastRevisionsForPath(final AbstractVcs vcs, final RepositoryLocation location, |
| final Convertor<T, String> pathConvertor, Set<T> files, final PairConsumer<T, PathState> consumer) |
| throws VcsException { |
| final String normalizedLocation = normalizeLocation(location); |
| if (! myKnownRepositoryLocations.exists(vcs.getName(), normalizedLocation)) return; |
| final long locationId = myKnownRepositoryLocations.getLocationId(vcs.getName(), normalizedLocation); |
| |
| if (files.size() < ourLastPathRevisionBatchSize) { |
| iterateGetPathState(vcs, location, pathConvertor, files, consumer); |
| return; |
| } |
| |
| String s = StringUtil.repeat("?,", ourLastPathRevisionBatchSize); |
| final String repeat = s.substring(0, s.length() - 1); |
| final PreparedStatement maxStatement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_SELECT_PATH_DATA_BATCH, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("SELECT MAX(R." + SqliteTables.REVISION.NUMBER_INT + ") MAX, P."+ SqliteTables.PATHS.PATH + |
| " PATH, P." + SqliteTables.PATHS.ID + " PATH_ID FROM " + SqliteTables.PATHS_2_REVS.TABLE_NAME + " PR INNER JOIN " + |
| SqliteTables.REVISION.TABLE_NAME + " R, " + SqliteTables.PATHS.TABLE_NAME + " P ON PR." + |
| SqliteTables.PATHS_2_REVS.REVISION_FK + "=R." + |
| SqliteTables.REVISION.ID + " AND PR." + SqliteTables.PATHS_2_REVS.PATH_FK + "=P." + SqliteTables.PATHS.ID + |
| " WHERE P." + SqliteTables.PATHS.PATH + " IN (" + repeat + ") AND R." + SqliteTables.REVISION.ROOT_FK + "=?"); |
| } |
| }); |
| final PreparedStatement typeStatement = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_PATHS_2_REVS_BATCH, |
| new ThrowableConvertor<Connection, PreparedStatement, SQLException>() { |
| @Override |
| public PreparedStatement convert(Connection connection) throws SQLException { |
| return connection.prepareStatement("SELECT PR." + SqliteTables.PATHS_2_REVS.TYPE + " TYPE, R." + |
| SqliteTables.REVISION.NUMBER_INT + " REV_NUM, PR." + SqliteTables.PATHS_2_REVS.PATH_FK + " PATH_ID " + |
| " FROM " + SqliteTables.PATHS_2_REVS.TABLE_NAME + |
| " PR INNER JOIN " + SqliteTables.REVISION.TABLE_NAME + " R ON PR." + SqliteTables.PATHS_2_REVS.REVISION_FK + "=R." + |
| SqliteTables.REVISION.ID + " WHERE R." + SqliteTables.REVISION.NUMBER_INT + " IN (" + repeat + |
| ") AND PR." + SqliteTables.PATHS_2_REVS.PATH_FK + " IN(" + repeat + ")"); |
| } |
| }); |
| final List<List<T>> split = new CollectionSplitter<T>(ourLastPathRevisionBatchSize).split(files); |
| try { |
| maxStatement.setLong(ourLastPathRevisionBatchSize + 1, locationId); |
| for (List<T> list : split) { |
| final Map<String, T> paths2elements = new HashMap<String, T>(); |
| final int size = list.size(); |
| if (size < ourLastPathRevisionBatchSize) { |
| iterateGetPathState(vcs, location, pathConvertor, list, consumer); |
| return; |
| } |
| for (int i = 0; i < size; i++) { |
| T t = list.get(i); |
| final String convert = pathConvertor.convert(t); |
| assert ! paths2elements.containsKey(convert); |
| paths2elements.put(convert, t); |
| maxStatement.setString(i + 1, convert); |
| } |
| |
| final ResultSet set = maxStatement.executeQuery(); |
| final Map<Long, Pair<Long, String>> maxMap = new HashMap<Long, Pair<Long, String>>(); |
| SqliteUtil.readSelectResults(set, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long maxRev = set.getLong("MAX"); |
| final String path = set.getString("PATH"); |
| final long pathId = set.getLong("PATH_ID"); |
| maxMap.put(pathId, Pair.create(maxRev, path)); |
| } |
| }); |
| |
| int i = 0; |
| for (Map.Entry<Long, Pair<Long, String>> entry : maxMap.entrySet()) { |
| typeStatement.setLong(i + 1, entry.getValue().getFirst()); // rev # |
| typeStatement.setLong(ourLastPathRevisionBatchSize + i + 1, entry.getKey()); // path id |
| ++ i; |
| } |
| final ResultSet detailsSet = typeStatement.executeQuery(); |
| SqliteUtil.readSelectResults(detailsSet, new ThrowableRunnable<SQLException>() { |
| @Override |
| public void run() throws SQLException { |
| final long type = detailsSet.getLong("TYPE"); |
| final ChangeTypeEnum changeType = ChangeTypeEnum.getChangeType(type); |
| if (changeType == null) { |
| LOG.info("Illegal change type: " + type); |
| return; |
| } |
| |
| final long revNum = detailsSet.getLong("REV_NUM"); |
| final long pathId = detailsSet.getLong("PATH_ID"); |
| |
| final Pair<Long, String> pair = maxMap.get(pathId); |
| if (pair.getFirst() == revNum) { |
| consumer.consume(paths2elements.get(pair.getSecond()), new PathState(revNum, ! ChangeTypeEnum.DELETE.equals(changeType))); |
| } |
| } |
| }); |
| } |
| } |
| catch (SQLException e) { |
| throw new VcsException(e); |
| } |
| }*/ |
| |
| /*private <T> void iterateGetPathState(AbstractVcs vcs, |
| RepositoryLocation location, |
| Convertor<T, String> pathConvertor, |
| Collection<T> files, |
| PairConsumer<T, PathState> consumer) throws VcsException { |
| for (T file : files) { |
| final PathState state = getPathState(vcs, location, pathConvertor.convert(file)); |
| consumer.consume(file, state); |
| } |
| }*/ |
| } |
