import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
private List<Relationship> getRelationshipsImpl(
    TableImpl table1, TableImpl table2, boolean includeSystemTables)
  throws IOException
{
  initRelationships();
  
  List<Relationship> relationships = new ArrayList<Relationship>();

  if(table1 != null) {
    Cursor cursor = createCursorWithOptionalIndex(
        _relationships, REL_COL_FROM_TABLE, table1.getName());
    collectRelationships(cursor, table1, table2, relationships,
                         includeSystemTables);
    cursor = createCursorWithOptionalIndex(
        _relationships, REL_COL_TO_TABLE, table1.getName());
    collectRelationships(cursor, table2, table1, relationships,
                         includeSystemTables);
  } else {
    collectRelationships(new CursorBuilder(_relationships).toCursor(),
                         null, null, relationships, includeSystemTables);
  }
  
  return relationships;
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
/**
 * Find collection of SIDs for the given parent id.
 */
private void collectNewObjectSIDs(Integer parentId, List<byte[]> sids) 
  throws IOException
{
  // search for ACEs matching the given parentId.  use the index on the
  // objectId column if found (should be there)
  Cursor cursor = createCursorWithOptionalIndex(
      getAccessControlEntries(), ACE_COL_OBJECT_ID, parentId);
  
  for(Row row : cursor) {
    Integer objId = row.getInt(ACE_COL_OBJECT_ID);
    if(parentId.equals(objId)) {
      sids.add(row.getBytes(ACE_COL_SID));
    }
  }

  if(sids.isEmpty()) {
    // if all else fails, use the hard-coded default
    sids.add(SYS_DEFAULT_SID);
  }
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
/**
 * Creates a Cursor restricted to the given column value if possible (using
 * an existing index), otherwise a simple table cursor.
 */
private Cursor createCursorWithOptionalIndex(
    TableImpl table, String colName, Object colValue)
  throws IOException
{
  try {
    return table.newCursor()
      .setIndexByColumnNames(colName)
      .setSpecificEntry(colValue)
      .toCursor();
  } catch(IllegalArgumentException e) {
    if(LOG.isDebugEnabled()) {
      LOG.debug(withErrorContext(
          "Could not find expected index on table " + table.getName()));
    } 
  }
  // use table scan instead
  return CursorImpl.createCursor(table);
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
private static void checkIndexEntries(final TestDB testDB, Table t, Index index) throws Exception
  {
//         index.initialize();
//         System.out.println("Ind " + index);

    Cursor cursor = CursorBuilder.createCursor(index);
    while(cursor.moveToNextRow()) {

      Row row = cursor.getCurrentRow();
      Cursor.Position curPos = cursor.getSavepoint().getCurrentPosition();
      boolean success = false;
      try {
        findRow(testDB, t, index, row, curPos);
        success = true;
      } finally {
        if(!success) {
          System.out.println("CurPos: " + curPos);
          System.out.println("Value: " + row + ": " + 
                             toUnicodeStr(row.get("data")));
        }          
      }
    }
    
  }
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public void x_testReadAllCodesMdb() throws Exception
  {
//     Database db = openCopy(new File("/data2/jackcess_test/testAllIndexCodes.mdb"));
//     Database db = openCopy(new File("/data2/jackcess_test/testAllIndexCodes_orig.mdb"));
//     Database db = openCopy(new File("/data2/jackcess_test/testSomeMoreCodes.mdb"));
    Database db = openCopy(Database.FileFormat.V2000, new File("/data2/jackcess_test/testStillMoreCodes.mdb"));
    Table t = db.getTable("Table5");

    Index ind = t.getIndexes().iterator().next();
    ((IndexImpl)ind).initialize();
    
    System.out.println("Ind " + ind);

    Cursor cursor = CursorBuilder.createCursor(ind);
    while(cursor.moveToNextRow()) {
      System.out.println("=======");
      String entryStr = 
        entryToString(cursor.getSavepoint().getCurrentPosition());
      System.out.println("Entry Bytes: " + entryStr);
      System.out.println("Value: " + cursor.getCurrentRow() + "; " +
                         toUnicodeStr(cursor.getCurrentRow().get("data")));
    }

    db.close();
  }
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public void x_testReadIsoMdb() throws Exception
  {
//     Database db = open(new File("/tmp/test_ind.mdb"));
//     Database db = open(new File("/tmp/test_ind2.mdb"));
    Database db = open(Database.FileFormat.V2000, new File("/tmp/test_ind3.mdb"));
//     Database db = open(new File("/tmp/test_ind4.mdb"));

    Table t = db.getTable("Table1");
    Index index = t.getIndex("B");
    ((IndexImpl)index).initialize();
    System.out.println("Ind " + index);

    Cursor cursor = CursorBuilder.createCursor(index);
    while(cursor.moveToNextRow()) {
      System.out.println("=======");
      System.out.println("Savepoint: " + cursor.getSavepoint());
      System.out.println("Value: " + cursor.getCurrentRow());
    }
    
    db.close();
  }
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public void testNoEnforceForeignKeys() throws Exception {
  for (final TestDB testDB : TestDB.getSupportedForBasename(Basename.INDEX)) {

    Database db = openCopy(testDB);
    db.setEnforceForeignKeys(false);
    Table t1 = db.getTable("Table1");
    Table t2 = db.getTable("Table2");
    Table t3 = db.getTable("Table3");

    t1.addRow(20, 0, 20, "some data", 20);

    Cursor c = CursorBuilder.createCursor(t2);
    c.moveToNextRow();
    c.updateCurrentRow(30, "foo30");

    c = CursorBuilder.createCursor(t3);
    c.moveToNextRow();
    c.deleteCurrentRow();

    db.close();
  }
  
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public IFeedbackAction  persist() throws SQLException {
	try {
		Cursor cur = indexSelector.getCursor();
		cur.beforeFirst();
		Collection<String> columnNames = composite.get(0).getRowPattern()
				.keySet();
		while (composite.size() > 0 && moveToNextRow(cur, columnNames)) {
			Iterator<ICursorCommand> it = composite.iterator();
			while (it.hasNext()) {
				ICursorCommand comm = it.next();
				if (comm.currentRowMatches(cur, this.currentRow)) {
					comm.persistCurrentRow(cur);
					it. remove();
					rollbackCache.add(comm);
					break;
				}
			}
		}
		return null;
	} catch (IOException e) {
		throw new UcanaccessSQLException(e);
	}
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public IFeedbackAction  persist() throws SQLException {
	try {
		Cursor cur = indexSelector.getCursor();
		if (cur.findNextRow(rowPattern)) {
			if (this.blobColumns != null) {
				for (Column col : this.blobColumns) {
					Object val = cur.getCurrentRowValue(col);
					modifiedRow[tableColumns.indexOf(col)] = val;
				}
			}
			updateComplex(cur );
			cur.updateCurrentRow(modifiedRow);
			
		}
	} catch (IOException e) {
		throw new UcanaccessSQLException(e);
	}
	return null;
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public Cursor getCursor() throws IOException {
	Index idx = getBestIndex();
	Cursor cursor;
	CursorBuilder cb=table.newCursor();
	if (idx == null)
		cursor = cb.toCursor();
	else
		cursor = cb.setIndex(idx).toCursor();
	cursor.setColumnMatcher(new ColumnMatcher());
	return cursor;
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
private static void debugTable(Table table, SequenceWriter columnCsv) throws IOException {

		System.out.println("\tTable columns for " + table.getName());

		try {
			for (Column nextColumn : table.getColumns()) {
				System.out.println("\t\t" + nextColumn.getName());
				columnCsv.write(Arrays.asList(table.getName() + "." + nextColumn.getName(),
						table.getName() + "." + nextColumn.getName(), "", ""));
			}

			Index primaryKeyIndex = table.getPrimaryKeyIndex();
			System.out.println(
					"\tFound primary key index for table: " + table.getName() + " named " + primaryKeyIndex.getName());
			debugIndex(primaryKeyIndex, new HashSet<>(), columnCsv);

			for (Index nextIndex : table.getIndexes()) {
				if (!nextIndex.getName().equals(primaryKeyIndex.getName())) {
					System.out.println("\tFound non-primary key index for table: " + table.getName() + " named "
							+ nextIndex.getName());
					debugIndex(nextIndex, new HashSet<>(), null);
				}
			}
		} catch (IllegalArgumentException e) {
			System.out.println("No primary key index found for table: " + table.getName());
		}

		Cursor cursor = table.getDefaultCursor();
		int i = 0;
		while (cursor.moveToNextRow()) {
			if (i >= 5) {
				break;
			}
			System.out.println(cursor.getCurrentRow().toString());
			i++;
		}
	}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public Integer findObjectId(Integer parentId, String name) 
  throws IOException 
{
  Cursor cur = findRow(parentId, name);
  if(cur == null) {  
    return null;
  }
  ColumnImpl idCol = _systemCatalog.getColumn(CAT_COL_ID);
  return (Integer)cur.getCurrentRowValue(idCol);
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public Row getObjectRow(Integer parentId, String name,
                        Collection<String> columns) 
  throws IOException 
{
  Cursor cur = findRow(parentId, name);
  return ((cur != null) ? cur.getCurrentRow(columns) : null);
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
@Override
protected Cursor findRow(Integer parentId, String name) 
  throws IOException 
{
  return (_systemCatalogCursor.findFirstRowByEntry(parentId, name) ?
          _systemCatalogCursor : null);
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
@Override
protected Cursor getTableNamesCursor() throws IOException {
  return _systemCatalogCursor.getIndex().newCursor()
    .setStartEntry(_tableParentId, IndexData.MIN_VALUE)
    .setEndEntry(_tableParentId, IndexData.MAX_VALUE)
    .toIndexCursor();
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
private static void findRow(final TestDB testDB, Table t, Index index,
                            Row expectedRow,
                            Cursor.Position expectedPos)
  throws Exception
{
  Object[] idxRow = ((IndexImpl)index).constructIndexRow(expectedRow);
  Cursor cursor = CursorBuilder.createCursor(index, idxRow, idxRow);

  Cursor.Position startPos = cursor.getSavepoint().getCurrentPosition();
  
  cursor.beforeFirst();
  while(cursor.moveToNextRow()) {
    Row row = cursor.getCurrentRow();
    if(expectedRow.equals(row)) {
      // verify that the entries are indeed equal
      Cursor.Position curPos = cursor.getSavepoint().getCurrentPosition();
      assertEquals(entryToString(expectedPos), entryToString(curPos));
      return;
    }
  }

  // TODO long rows not handled completely yet in V2010
  // seems to truncate entry at 508 bytes with some trailing 2 byte seq
  if(testDB.getExpectedFileFormat() == Database.FileFormat.V2010) {
    String rowId = expectedRow.getString("name");
    String tName = t.getName();
    if(("Table11".equals(tName) || "Table11_desc".equals(tName)) &&
       ("row10".equals(rowId) || "row11".equals(rowId) || 
        "row12".equals(rowId))) {
      System.out.println(
          "TODO long rows not handled completely yet in V2010: " + tName +
                         ", " + rowId);
      return;
    }
  }

  fail("testDB: " + testDB + ";\nCould not find expected row " + expectedRow + " starting at " +
       entryToString(startPos));
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public static String entryToString(Cursor.Position curPos)
  throws Exception
{
  Field eField = curPos.getClass().getDeclaredField("_entry");
  eField.setAccessible(true);
  IndexData.Entry entry = (IndexData.Entry)eField.get(curPos);
  Field ebField = entry.getClass().getDeclaredField("_entryBytes");
  ebField.setAccessible(true);
  byte[] entryBytes = (byte[])ebField.get(entry);

  return ByteUtil.toHexString(ByteBuffer.wrap(entryBytes),
                              0, entryBytes.length, false);
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public boolean moveToNextRow(Cursor cur, Collection<String> columnNames)
		throws IOException {
	boolean hasNext = cur.moveToNextRow();
	if (hasNext) {
		this.currentRow = cur.getCurrentRow(columnNames);
	}
	return hasNext;
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public IFeedbackAction  persist() throws SQLException {
	try {
		Cursor cur = indexSelector.getCursor();
		if (cur.findNextRow(rowPattern)) {
			cur.deleteCurrentRow();
		}
	} catch (IOException e) {
		throw new UcanaccessSQLException(e);
	}
	return null;
}
 

import com.healthmarketscience.jackcess.Cursor; //导入依赖的package包/类
public void persistCurrentRow(Cursor cur) throws IOException {
	if (this.blobColumns != null) {
		for (Column col : this.blobColumns) {
			Object val = cur.getCurrentRowValue(col);
			modifiedRow[tableColumns.indexOf(col)] = val;
			
		}
	}
	updateComplex(cur);
	cur.updateCurrentRow(modifiedRow);
}