public class test {
    public static void main(String[] argv) {

        // construct a 3-column table schema
        Type types[] = new Type[]{ Type.INT_TYPE, Type.INT_TYPE, Type.INT_TYPE };
        String names[] = new String[]{ "field0", "field1", "field2" };
        TupleDesc descriptor = new TupleDesc(types, names);
        
        // create the table, associate it with some_data_file.dat
        // and tell the catalog about the schema of this table.
        HeapFile table1 = new HeapFile(new File("some_data_file.dat"), descriptor);
        Database.getCatalog().addTable(table1, "test");
        
        // construct the query: we use a simple SeqScan, which spoonfeeds
        // tuples via its iterator.
        TransactionId tid = new TransactionId();
        SeqScan f = new SeqScan(tid, table1.getId());
        
        try {
            // and run it
            f.open();
            while (f.hasNext()) {
                Tuple tup = f.next();
                System.out.println(tup);
            }
            f.close();
            Database.getBufferPool().transactionComplete(tid);
        } catch (Exception e) {
            System.out.println ("Exception : " + e);
        }
    }
}

// construct a 3-column table schema
Type types[] = new Type[]{ Type.INT_TYPE, Type.INT_TYPE, Type.INT_TYPE };
String names[] = new String[]{ "field0", "field1", "field2" };
TupleDesc descriptor = new TupleDesc(types, names);

// create the table, associate it with some_data_file.dat
// and tell the catalog about the schema of this table.
HeapFile table1 = new HeapFile(new File("some_data_file.dat"), descriptor);
Database.getCatalog().addTable(table1, "test");

// HeapFile的iterator，见下
HeapFileIterator
// 构造方法，传入file和tuple desc
HeapFile(File f, TupleDesc td);
// 读取页(真正和磁盘打交道的地方)，一页默认4096Byte，其中pid保存第几页信息，直接seek过去读取
Page readPage(PageId pid);
// 写入页(真正和磁盘打交道的地方)，同上，page包含有第几页，直接seek过去写入
void writePage(Page page);
// 根据文件的大小，看看有多少页（ceil(size / page_size)）
int numPages();
// 插入一个tuple。如果前面有空槽，写空槽里；否则新建一个页。会从BufferPool获取页(所有读取页的操作都会从BufferPool走)
// 写完会在tuple中写入record信息(主要保存文件id和页数信息)。
// 返回受到影响的页
ArrayList<Page> insertTuple(TransactionId tid, Tuple t);
// 删除一个tuple。tuple中含有文件和页数的信息。会从BufferPool获取页。
// 返回受影响的页
Page deleteTuple(TransactionId tid, Tuple t);
// 相关成员变量
private TupleDesc td;
private File f;
private int numPage

private int pagePos;
private Iterator<Tuple> tuplesInPage;
private TransactionId tid;
//
HeapFileIterator(TransactionId tid);
// pagePos = 0, 加载页并赋值给tuplesInPage
void open();
// 从buffer pool中读取HeapPage，返回page.iterator(), HeapPage的iterator见下，其功能就是返回这个page的所有tuples
Iterator<Tuple> getTuplesInPage(HeapPageId pid);
// 首先检查当前page.hasNext()，没有则检查是不是最后一页，是则返回false，否则赋值下一页的iterator
boolean hasNext();
// tuplesInPage.next();
Tuple next();

// 该heap page所在的页(对应物理上磁盘位置)
HeapPageId pid;
// 该页的tuple desc，所以一个页都应该是一种schema
TupleDesc td;
// header
byte header[];
// data
Tuple tuples[];
// 有多少slots，即tuples和header的大小
int numSlots;
// 磁盘上的旧数据
byte[] oldData;
// 当前page被哪个transactionid持有
private TransactionId lastDirtyOperation;
// 构造函数，初始化pid/td/numSlots，从data中构建header和tuples信息，并初始化。oldData = data
HeapPage(HeapPageId id, byte[] data);
// ((BufferPool.PAGE_SIZE * 8) /  (td.getSize() * 8 + 1))
int getNumTuples();
// Math.ceil(this.numSlots / 8.0)
int getHeaderSize();
// 读取dis信息构建tuple
private Tuple readNextTuple(DataInputStream dis, int slotId);
// 删除某个tuple
public void deleteTuple(Tuple t);
// 找到一个空闲的slot，插入tuple，并设置相应的header
public void insertTuple(Tuple t);
// 返回当前tuples的一个iterator
Iterator<Tuple> iterator();

// table和id的对应关系，这里的id是file的id，也就是file绝对路径的hashcode
private Map<Integer, Table> id2table;
private Map<String, Integer> name2id;
// 增加一个table，更新上面2个变量，这里用到了Table这个类，见下面描述
void addTable(DbFile file, String name, String pkeyField);
// id2table.clear(); & name2id.clear();
void clear();
// 这个方法比较关键，最初读取schema文件的时候，都是这个方法
// 简单来说，这个方法读取schema文件，文件内容类似这样 table_name (field1 type1, field2 type2, ...)
// --------
// authors (id int, name string)
// venues (id int, name string, year int, type int)
// papers (id int, title string, venueid int)
// paperauths (paperid int, authorid int)
// --------
// 1. 逐行读取table schema，找到schema父目录下同名.dat文件作为data文件，例如 authors.dat
// 2. 接下来两行和之前如出一辙，读取data文件，加入到Catalog中
// 	HeapFile tabHf = new HeapFile(new File(baseFolder + "/" + name + ".dat"), t);
// 	addTable(tabHf, name, primaryKey);
void loadSchema(String catalogFile);

private DbFile dbFile; // 文件
private String name; // table名称
private String pkeyField; // 主键名称

// construct the query: we use a simple SeqScan, which spoonfeeds
// tuples via its iterator.
TransactionId tid = new TransactionId();
SeqScan f = new SeqScan(tid, table1.getId());

try {
    // and run it
    f.open();
    while (f.hasNext()) {
        Tuple tup = f.next();
        System.out.println(tup);
    }
    f.close();
    Database.getBufferPool().transactionComplete(tid);
} catch (Exception e) {
    System.out.println ("Exception : " + e);
}

// 变量
private TransactionId tid;
private int tableid;
private String tableAlias;
private DbFileIterator iterator;
// catalog.dbfile(tableid).iterator，返回heapfile的iterator
SeqScan(TransactionId tid, int tableid, String tableAlias);
public SeqScan(TransactionId tid, int tableid) {
    this(tid, tableid, Database.getCatalog().getTableName(tableid));
}
// iterator.open();
void open();

public class JoinMainTest {

    public static void main(String[] argv) {
        // construct a 3-column table schema
        Type types[] = new Type[]{Type.INT_TYPE, Type.INT_TYPE, Type.INT_TYPE};
        String names[] = new String[]{"field0", "field1", "field2"};
        if (argv.length != 2) {
            System.out.println("Illegal arguments");
            System.out.println("  ./program file1.dat file2.dat");
            System.exit(1);
        }

        System.out.println(Arrays.toString(argv));
        TupleDesc td = new TupleDesc(types, names);

        // create the tables, associate them with the data files
        // and tell the catalog about the schema  the tables.
        HeapFile table1 = new HeapFile(new File(argv[0]), td);
        Database.getCatalog().addTable(table1, "t1");

        HeapFile table2 = new HeapFile(new File(argv[1]), td);
        Database.getCatalog().addTable(table2, "t2");

        // construct the query: we use two SeqScans, which spoonfeed
        // tuples via iterators into join
        TransactionId tid = new TransactionId();

        SeqScan ss1 = new SeqScan(tid, table1.getId(), "t1");
        SeqScan ss2 = new SeqScan(tid, table2.getId(), "t2");

        // create a filter for the where condition
        Filter sf1 = new Filter(
                new Predicate(0,
                        Predicate.Op.GREATER_THAN, new IntField(1)), ss1);

        JoinPredicate p = new JoinPredicate(1, Predicate.Op.EQUALS, 1);
        Join j = new Join(p, sf1, ss2);

        // and run it
        try {
            j.open();
            while (j.hasNext()) {
                Tuple tup = j.next();
                System.out.println(tup);
            }
            j.close();
            Database.getBufferPool().transactionComplete(tid);

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

// create a filter for the where condition
Filter sf1 = new Filter(
        new Predicate(0,
                Predicate.Op.GREATER_THAN, new IntField(1)), ss1);

// 传入的具体的操作
private Predicate p;
// 一般是seqscan，也可能是【责任链模式】的前一个结果
private DbIterator child;
// 把过滤的结果缓存下来
private TupleIterator filterResult;
// 构造函数
public Filter(Predicate p, DbIterator child);
// 调用filter，将filter的结果传给filterResult，并open()
public void open();
// 对每一个tuple，执行p.filter(tuple)，true则添加到结果中
private TupleIterator filter(Predicate p, DbIterator child);
// 其他都是一些简单的方法

// 比较符号，有 EQUALS, GREATER_THAN, LESS_THAN, LESS_THAN_OR_EQ, GREATER_THAN_OR_EQ, LIKE, NOT_EQUALS
private Op op;
// 待比较的field的index
private int field;
// 操作数，
private Field operand;
// 具体的比较操作，在IntField和StringField中有定义
public boolean filter(Tuple t) { return t.getField(field).compare(op, operand); }

// join的predicate，等价于 where t1.id = t2.id，p.filter(tup1, tup2)
private JoinPredicate p;
// 待合并的两个tuples
private DbIterator child1;
private DbIterator child2;
// 合并之后的tupledesc，就是将两个表拼接一起
private TupleDesc td;
// 保存合并后的结果
private TupleIterator filterResult;
// 主要介绍filter。遍历两个iter，判断是否满足p.filter(tup1, tup2)，满足则合并并加入到filterResult中
private TupleIterator filter(JoinPredicate p, DbIterator child1, DbIterator child2);

// 
private TransactionId transactionId;
private DbIterator child;
private int tableid;
private TupleDesc td;
// 影响的tuple数量
private int count;
// 是否完成插入标志
private boolean hasAccessed;
// 会调用buffer pool中的insertTuple的方法(记得这个方法最终都会调用getPage，进而保证事务)
public void open();

public Vector<LogicalJoinNode> orderJoins(
        HashMap<String, TableStats> stats,
        HashMap<String, Double> filterSelectivities, boolean explain)

// 首先检测该pid是否可以被当前tid获取锁（写锁or读锁）
boolean result = (perm == Permissions.READ_ONLY) ? lockManager.grantSLock(tid, pid) : lockManager.grantXLock(tid, pid);
// 下面的while循环就是在模拟等待过程，如果没有获取到锁，隔一段时间就检查一次是否申请到锁了，还没申请到就检查是否陷入死锁
while (!result) {
    // 死锁检测
    if (lockManager.deadlockOccurred(tid, pid)) {
        throw new TransactionAbortedException();
    }
    try {
        Thread.sleep(SLEEP_INTERVAL);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //sleep之后再次判断result
    result = (perm == Permissions.READ_ONLY) ? lockManager.grantSLock(tid, pid) : lockManager.grantXLock(tid, pid);
}