How to use

ViewIndex

in

org.h2.index

@Override
protected Cursor run() throws Exception {
  viewIndex.setupQueryParameters(viewIndex.getSession(), first, last, null);
  ArrayList<JoinBatch> joinBatches = batchUnion.joinBatches;
  for (int i = 0, size = joinBatches.size(); i < size; i++) {
    assert topFutureCursors[i] != null;
    joinBatches.get(i).viewTopFutureCursor = topFutureCursors[i];
  }
  ResultInterface localResult;
  boolean lazy = false;
  try {
    localResult = viewIndex.getQuery().query(0);
    lazy = localResult.isLazy();
  } finally {
    if (!lazy) {
      resetViewTopFutureCursorAfterQuery();
    }
  }
  return newCursor(localResult);
}

@Override
public PlanItem getBestPlanItem(Session session, int[] masks,
    TableFilter[] filters, int filter, SortOrder sortOrder,
    HashSet<Column> allColumnsSet) {
  final CacheKey cacheKey = new CacheKey(masks, this);
  Map<Object, ViewIndex> indexCache = session.getViewIndexCache(topQuery != null);
  ViewIndex i = indexCache.get(cacheKey);
  if (i == null || i.isExpired()) {
    i = new ViewIndex(this, index, session, masks, filters, filter, sortOrder);
    indexCache.put(cacheKey, i);
  }
  PlanItem item = new PlanItem();
  item.cost = i.getCost(session, masks, filters, filter, sortOrder, allColumnsSet);
  item.setIndex(i);
  return item;
}

initBaseIndex(view, 0, null, null, IndexType.createNonUnique(false));
this.view = view;
this.querySQL = index.querySQL;
columns = new Column[0];
if (!recursive) {
  query = getQuery(session, masks, filters, filter, sortOrder);

private Cursor find(Session session, SearchRow first, SearchRow last,
    SearchRow intersection) {
  if (recursive) {
    return findRecursive(first, last);
  }
  setupQueryParameters(session, first, last, intersection);
  ResultInterface result = query.query(0);
  return new ViewCursor(this, result, first, last);
}

/**
 * @param f Table filter.
 * @return Sub-query.
 */
private static Query getSubQuery(TableFilter f) {
  return ((ViewIndex)f.getIndex()).getQuery();
}

public PlanItem getBestPlanItem(Session session, int[] masks) throws SQLException {
  PlanItem item = new PlanItem();
  item.cost = index.getCost(session, masks);
  IntArray masksArray = new IntArray(masks == null ? new int[0] : masks);
  ViewIndex i2 = (ViewIndex) indexCache.get(masksArray);
  if (i2 == null || i2.getSession() != session) {
    i2 = new ViewIndex(this, index, session, masks);
    indexCache.put(masksArray, i2);
  }
  item.setIndex(i2);
  return item;
}

@Override
public final boolean addSearchRows(SearchRow first, SearchRow last) {
  resetAfterFind();
  viewIndex.setupQueryParameters(viewIndex.getSession(), first, last, null);
  R r;
  if (resultSize < result.size()) {
    // get reused runner
    r = queryRunner(resultSize);
  } else {
    // create new runner
    result.add(r = newQueryRunner());
  }
  r.first = first;
  r.last = last;
  if (!collectSearchRows(r)) {
    r.clear();
    return false;
  }
  resultSize++;
  return true;
}

boolean res = result.next();
if (!res) {
  if (index.isRecursive()) {
    result.reset();
  } else {
  comp = index.compareRows(current, first);
  if (comp < 0) {
    continue;
  comp = index.compareRows(current, last);
  if (comp > 0) {
    continue;

private synchronized void init(String querySQL, ArrayList<Parameter> params,
    Column[] columnTemplates, Session session, boolean allowRecursive, boolean literalsChecked,
    boolean isTableExpression, boolean isPersistent) {
  this.querySQL = querySQL;
  this.columnTemplates = columnTemplates;
  this.allowRecursive = allowRecursive;
  this.isRecursiveQueryDetected = false;
  this.isTableExpression = isTableExpression;
  this.isPersistent = isPersistent;
  index = new ViewIndex(this, querySQL, params, allowRecursive);
  initColumnsAndTables(session, literalsChecked);
}

/**
 * Constructor for the original index in {@link TableView}.
 *
 * @param view the table view
 * @param querySQL the query SQL
 * @param originalParameters the original parameters
 * @param recursive if the view is recursive
 */
public ViewIndex(TableView view, String querySQL,
    ArrayList<Parameter> originalParameters, boolean recursive) {
  initBaseIndex(view, 0, null, null, IndexType.createNonUnique(false));
  this.view = view;
  this.querySQL = querySQL;
  this.originalParameters = originalParameters;
  this.recursive = recursive;
  columns = new Column[0];
  this.createSession = null;
  this.indexMasks = null;
  // this is a main index of TableView, it does not need eviction time
  // stamp
  evaluatedAt = Long.MIN_VALUE;
}

  cols[i] = columnTemplates[i].getClone();
index.setRecursive(true);
createException = null;

@Override
public Cursor find(Session session, SearchRow first, SearchRow last) {
  return find(session, first, last, null);
}

public ViewCursor(ViewIndex index, ResultInterface result, SearchRow first,
    SearchRow last) {
  this.table = index.getTable();
  this.index = index;
  this.result = result;
  this.first = first;
  this.last = last;
}

boolean initialize() {
  return collectJoinBatches(viewIndex.getQuery()) && joinBatches != null;
}

@Override
public final boolean addSearchRows(SearchRow first, SearchRow last) {
  resetAfterFind();
  viewIndex.setupQueryParameters(viewIndex.getSession(), first, last, null);
  R r;
  if (resultSize < result.size()) {
    // get reused runner
    r = queryRunner(resultSize);
  } else {
    // create new runner
    result.add(r = newQueryRunner());
  }
  r.first = first;
  r.last = last;
  if (!collectSearchRows(r)) {
    r.clear();
    return false;
  }
  resultSize++;
  return true;
}

private Cursor find(Session session, SearchRow first, SearchRow last,
    SearchRow intersection) {
  if (recursive) {
    return findRecursive(first, last);
  }
  setupQueryParameters(session, first, last, intersection);
  LocalResult result = query.query(0);
  return new ViewCursor(this, result, first, last);
}

boolean res = result.next();
if (!res) {
  if (index.isRecursive()) {
    result.reset();
  } else {
  comp = index.compareRows(current, first);
  if (comp < 0) {
    continue;
  comp = index.compareRows(current, last);
  if (comp > 0) {
    continue;

private synchronized void init(String querySQL, ArrayList<Parameter> params,
    Column[] columnTemplates, Session session, boolean recursive) {
  this.querySQL = querySQL;
  this.columnTemplates = columnTemplates;
  this.recursive = recursive;
  index = new ViewIndex(this, querySQL, params, recursive);
  initColumnsAndTables(session);
}

public ViewIndex(TableView view, String querySQL, ObjectArray originalParameters, boolean recursive) {
  initBaseIndex(view, 0, null, null, IndexType.createNonUnique(false));
  this.querySQL = querySQL;
  this.originalParameters = originalParameters;
  this.recursive = recursive;
  columns = new Column[0];
}

  cols[i] = columnTemplates[i].getClone();
index.setRecursive(true);
createException = null;