yetangitu/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2025-10-04 18:29:37 +02:00
Code Issues Releases Wiki Activity

Renamed Record class to DBRecord

Browse source
This commit is contained in:
ghidra1 2020-12-28 13:30:36 -05:00
parent 04276e9522
commit db1e3d1b62
305 changed files with 1902 additions and 1959 deletions
Download patch file Download diff file Expand all files Collapse all files

132
Ghidra/Framework/DB/src/test/java/db/DBIndexedTableTest.java
View file

@ -87,11 +87,11 @@ public class DBIndexedTableTest extends AbstractGenericTest {
* @param varDataSize size of variable length data fields.
* @return Record[] records which were inserted.
*/
private Record[] createRandomTableRecords(int schemaType, int recordCnt, int varDataSize)
private DBRecord[] createRandomTableRecords(int schemaType, int recordCnt, int varDataSize)
throws IOException {
long txId = dbh.startTransaction();
Table table = DBTestUtils.createLongKeyTable(dbh, table1Name, schemaType, true, false);
Record[] recs = new Record[recordCnt];
DBRecord[] recs = new DBRecord[recordCnt];
for (int i = 0; i < recordCnt; i++) {
try {
recs[i] = DBTestUtils.createLongKeyRecord(table, true, varDataSize, true);
@ -111,12 +111,12 @@ public class DBIndexedTableTest extends AbstractGenericTest {
* @param varDataSize size of variable length data fields.
* @return Record[] records which were inserted.
*/
private Record[] createOrderedTableRecords(int schemaType, int recordCnt, long keyIncrement,
private DBRecord[] createOrderedTableRecords(int schemaType, int recordCnt, long keyIncrement,
int varDataSize) throws IOException {
long txId = dbh.startTransaction();
Table table = DBTestUtils.createLongKeyTable(dbh, table1Name, schemaType, true, false);
long key = 0;
Record[] recs = new Record[recordCnt];
DBRecord[] recs = new DBRecord[recordCnt];
for (int i = 0; i < recordCnt; i++) {
try {
recs[i] = DBTestUtils.createRecord(table, key, varDataSize, true);
@ -130,19 +130,19 @@ public class DBIndexedTableTest extends AbstractGenericTest {
return recs;
}
private Field[] matchingKeys(Record[] recs, int columnIx, Record matchRec) {
ArrayList<Record> recList = new ArrayList<>();
private Field[] matchingKeys(DBRecord[] recs, int columnIx, DBRecord matchRec) {
ArrayList<DBRecord> recList = new ArrayList<>();
Field f = matchRec.getField(columnIx);
for (Record rec : recs) {
for (DBRecord rec : recs) {
if (f.equals(rec.getField(columnIx))) {
recList.add(rec);
}
}
Field[] keys = new Field[recList.size()];
Iterator<Record> iter = recList.iterator();
Iterator<DBRecord> iter = recList.iterator();
int i = 0;
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
keys[i++] = rec.getKeyField();
}
Arrays.sort(keys);
@ -151,7 +151,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
private void findRecords(boolean testStoredDB, int recordCnt, int findCnt, int varDataSize)
throws IOException {
Record[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize);// short var-len fields
DBRecord[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize);// short var-len fields
if (testStoredDB) {
saveAsAndReopen(dbName);
}
@ -239,7 +239,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
private void updateRecordsIterator(boolean testStoredDB, int schemaType, int recordCnt,
long keyIncrement, int varDataSize) throws IOException {
Record[] recs = null;
DBRecord[] recs = null;
if (keyIncrement == 0) {
recs = createRandomTableRecords(schemaType, recordCnt, varDataSize);
}
@ -307,7 +307,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
int recIx = 0;
RecordIterator iter = table.indexIterator(colIx);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -317,7 +317,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx),
recs[recIx].getKeyField());
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -327,7 +327,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx),
recs[recIx].getKeyField());
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -337,7 +337,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx),
recs[recIx].getKeyField());
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -346,7 +346,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = findStart(recs, recordCnt / 2, colIx);
iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx));
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -355,7 +355,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = recordCnt - 1;
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx));
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -364,7 +364,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = findEnd(recs, recordCnt / 2, colIx);
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx));
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -377,7 +377,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() - 1);
iter = table.indexIteratorAfter(colIx, startValue);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -387,7 +387,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() + 1);
iter = table.indexIteratorBefore(colIx, startValue);
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -411,7 +411,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
private void iterateRecords(boolean testStoredDB, int schemaType, int recordCnt,
long keyIncrement, int varDataSize, boolean doUndoRedo) throws IOException {
Record[] recs = null;
DBRecord[] recs = null;
if (keyIncrement == 0) {
recs = createRandomTableRecords(schemaType, recordCnt, varDataSize);
}
@ -444,7 +444,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = 0;
iter = table.indexIterator(colIx);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx], rec);
Field indexField = recs[recIx].getField(colIx);
if (lastIndex == null || !lastIndex.equals(indexField)) {
@ -474,7 +474,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = findEnd(recs, startIx, colIx);
iter = table.indexIteratorAfter(colIx, recs[startIx].getField(colIx));
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -486,7 +486,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorBefore(colIx, recs[startIx].getField(colIx),
recs[startIx].getKeyField());
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -502,7 +502,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = 0;
iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx));
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -523,7 +523,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx),
recs[recIx].getKeyField());
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -537,7 +537,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = recordCnt - 1;
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx));
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -547,7 +547,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx),
recs[recIx].getKeyField());
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -557,7 +557,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx),
recs[recIx].getKeyField());
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -566,7 +566,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = findStart(recs, recordCnt / 2, colIx);
iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx));
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -575,7 +575,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = findStart(recs, recordCnt / 2, colIx);
iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx));
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[--recIx], rec);
}
assertEquals(0, recIx);
@ -584,7 +584,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = findEnd(recs, recordCnt / 2, colIx);
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx));
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[++recIx], rec);
}
assertEquals(recordCnt - 1, recIx);
@ -593,7 +593,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = findEnd(recs, recordCnt / 2, colIx);
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx));
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -605,7 +605,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIterator(colIx, recs[minIx].getField(colIx),
recs[maxIx].getField(colIx), true);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(maxIx + 1, recIx);
@ -614,7 +614,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = 0;
iter = table.indexIterator(colIx, null, null, true);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -626,7 +626,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIterator(colIx, recs[minIx].getField(colIx),
recs[maxIx].getField(colIx), false);
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(minIx - 1, recIx);
@ -635,7 +635,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
recIx = recordCnt - 1;
iter = table.indexIterator(colIx, null, null, false);
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -653,7 +653,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() - 1);
iter = table.indexIteratorAfter(colIx, startValue);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -663,7 +663,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() + 1);
iter = table.indexIteratorBefore(colIx, startValue);
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -676,26 +676,26 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx));
for (int i = 0; i < 2; i++) {
if (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
}
--recIx;
for (int i = 0; i < 2; i++) {
if (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
}
++recIx;
for (int i = 0; i < 2; i++) {
if (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
}
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -706,26 +706,26 @@ public class DBIndexedTableTest extends AbstractGenericTest {
--recIx;
for (int i = 0; i < 2; i++) {
if (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
}
++recIx;
for (int i = 0; i < 2; i++) {
if (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
}
--recIx;
for (int i = 0; i < 2; i++) {
if (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
}
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -735,13 +735,13 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx));
for (int i = 0; i < 3; i++) {
if (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
}
assertEquals(recordCnt - 1, recIx);
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(-1, recIx);
@ -751,13 +751,13 @@ public class DBIndexedTableTest extends AbstractGenericTest {
iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx));
for (int i = 0; i < 3; i++) {
if (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[--recIx], rec);
}
}
assertEquals(0, recIx);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(recordCnt, recIx);
@ -870,7 +870,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
private void deleteIteratedRecords(int recordCnt, int testColIx, long keyIncrement,
int varDataSize) throws IOException {
Record[] recs = null;
DBRecord[] recs = null;
if (keyIncrement == 0) {
recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize);
}
@ -938,7 +938,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
private void deleteIteratedIndexFields(int recordCnt, int testColIx, long keyIncrement,
int varDataSize) throws Exception {
Record[] recs = null;
DBRecord[] recs = null;
if (keyIncrement == 0) {
recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize);
}
@ -956,7 +956,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
int fieldCnt = 0;
Field lastField = null;
ArrayList<Field> fieldList = new ArrayList<>();
for (Record rec : recs) {
for (DBRecord rec : recs) {
Field f = rec.getField(testColIx);
if (lastField == null || !lastField.equals(f)) {
lastField = f;
@ -1009,7 +1009,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
int fieldCnt = 0;
Field lastField = null;
ArrayList<Field> fieldList = new ArrayList<>();
for (Record rec : recs) {
for (DBRecord rec : recs) {
Field f = rec.getField(testColIx);
if (lastField == null || !lastField.equals(f)) {
lastField = f;
@ -1037,7 +1037,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
}
}
private int findStart(Record[] recs, int startIx, int colIx) {
private int findStart(DBRecord[] recs, int startIx, int colIx) {
Field f = recs[startIx].getField(colIx);
--startIx;
while (startIx >= 0 && f.equals(recs[startIx].getField(colIx))) {
@ -1049,7 +1049,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
return ++startIx;
}
private int findEnd(Record[] recs, int startIx, int colIx) {
private int findEnd(DBRecord[] recs, int startIx, int colIx) {
Field f = recs[startIx].getField(colIx);
++startIx;
while (startIx < recs.length && f.equals(recs[startIx].getField(colIx))) {
@ -1061,7 +1061,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
return --startIx;
}
private class RecColumnComparator implements Comparator<Record> {
private class RecColumnComparator implements Comparator<DBRecord> {
final int columnIx;
@ -1073,7 +1073,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
*/
@Override
public int compare(Record rec1, Record rec2) {
public int compare(DBRecord rec1, DBRecord rec2) {
int r = rec1.getField(columnIx).compareTo(rec2.getField(columnIx));
if (r == 0) {
if (rec1.getKey() == rec2.getKey()) {
@ -1156,7 +1156,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
@Test
public void testRecordIteratorExtents() throws IOException {
Record[] recs = null;
DBRecord[] recs = null;
recs = createOrderedRecordRange(DBTestUtils.SINGLE_SHORT, 30, 2, 1);
Table table = dbh.getTable(table1Name);
assertEquals(recs.length, table.getRecordCount());
@ -1174,17 +1174,17 @@ public class DBIndexedTableTest extends AbstractGenericTest {
Field maxField = new ShortField(Short.MAX_VALUE);
RecordIterator iter = table.indexIterator(colIx, minField, maxField, false);
while (iter.hasPrevious()) {
Record rec = iter.previous();
DBRecord rec = iter.previous();
assertEquals(recs[recIx--], rec);
}
assertEquals(recIx, -1);
}
private Record[] createOrderedRecordRange(int schemaType, int recordCnt, long keyIncrement,
private DBRecord[] createOrderedRecordRange(int schemaType, int recordCnt, long keyIncrement,
int varDataSize) throws IOException {
long txId = dbh.startTransaction();
Table table = DBTestUtils.createLongKeyTable(dbh, table1Name, schemaType, true, false);
Record[] recs = new Record[recordCnt];
DBRecord[] recs = new DBRecord[recordCnt];
for (int key = 0; key < recordCnt; key++) {
try {
recs[key] = DBTestUtils.createMidRangeRecord(table, key, varDataSize, true);
@ -1220,7 +1220,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
@Test
public void testConsistencyAndIndexRebuild() throws IOException {
Record[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, ITER_REC_CNT, 10);
DBRecord[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, ITER_REC_CNT, 10);
long txId = dbh.startTransaction();
try {
@ -1240,7 +1240,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
int recIx = 0;
RecordIterator iter = table.indexIterator(colIx);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(ITER_REC_CNT, recIx);
@ -1254,7 +1254,7 @@ public class DBIndexedTableTest extends AbstractGenericTest {
int recIx = 0;
RecordIterator iter = table.indexIterator(colIx);
while (iter.hasNext()) {
Record rec = iter.next();
DBRecord rec = iter.next();
assertEquals(recs[recIx++], rec);
}
assertEquals(ITER_REC_CNT, recIx);