Author: Sixing Yan

相关信息
What is BosCollege-SimpleDB? see this.
What is BosCollege-SimpleDB v3.0? see this.

前提提要
这一节将分析Client端发送SQL语句，Server端执行SQL语句的全过程。 我们首先从FindMajors.java入手，探究SimpleDB如何执行一条select查询语句。本文涉及的文件

Step 0

客户端执行一条SQL语句，将该SQL传入Server端并获得结果集，循环访问结果集获取数据记录。
/studentClient/simpledb/FindMajors.java

public class FindMajors {
    public static void main(String[] args) {
        ...
        Connection conn = null;
        try {
            // Step 1: connect to database server
            ...
            // Step 2: execute the query
            Statement stmt = conn.createStatement();
            String qry = "select sname, gradyear "
                       + "from student, dept "
                       + "where did = majorid "
                       + "and dname = '" + major + "'";
            ResultSet rs = stmt.executeQuery(qry);

            // Step 3: loop through the result set
            while (rs.next()) {
                String sname = rs.getString("sname");
                int gradyear = rs.getInt("gradyear");
                System.out.println(sname + "\t" + gradyear);}
            rs.close();
        }...}}

Step 1

stage 1-1

(a) pre-request

Obtain sstmt, an instance of SimpleStatement class
生成一个SimpleStatement类的变量stmt，它实际封装了RemoteStatement类的变量rstmt

• SimpleStatement(rstmt) <- SimpleConnection.createStatement()
  rstmt <= RemoteStatementImpl(rconn)
  • SimpleConnection封装了RemoteConnectionImpl
  • 实际执行 rstmt:RemoteStatement <- rconn.createStatement()

(b) process

Obtain srs, an instance of SimpleResultSet class
由rstmt执行executeQuery(queryString)，生成由SimpleResultSet封装的RemoteResultSetImpl类的变量

RemoteStatementImpl.java

  public RemoteResultSet executeQuery(String qry) throws RemoteException {
      try {
         Transaction tx = rconn.getTransaction();
         Plan pln = SimpleDB.planner().createQueryPlan(qry, tx);
         return new RemoteResultSetImpl(pln, rconn);
      }...}

• SimpleResultSet(rrs)<-rstmt.executeQuery(qry)
• rrs <= RemoteResultSetImpl(pln,rconn)
  • tx:Transaction <- rconn.getTransaction()
  • pln:Plan <- SimpleDB.planner().createQueryPlan(qry, tx)
  • rrs has 3 members:
    • s:Scan <- pln.open()
    • sch:Schema <- pln.schema()
    • rconn <- rconn

接下来我们看SimpleDB.planner().createQueryPlan(queryString, transaction)完成了哪些工作

stage 1-2

what SimpleDB.planner().createQueryPlan(qry, tx) do?
我们首先看SimpleDB.planner()的工作，它负责初始化server端的planner类实例。
/server/SimpleDB.java

  public static Planner planner() {
      QueryPlanner  qplanner = new BasicQueryPlanner();
      UpdatePlanner uplanner = new BasicUpdatePlanner();
      return new Planner(qplanner, uplanner);
   }

这里实际上是由BasicQueryPlanner类的实例来构造Query plan的工作（如果是create/update等操作则使用BasicUpdatePlanner类）。

• pln <- qplanner.createQueryPlan(qry, tx)
  • data:QueryData <- Parser(qry).query()
  • qplanner <- BasicQueryPlanner(data, tx)

首先使用Parser类（/parse/Parser.java）来解析SQL语句，形成QueryTree以方便调用。

现在探究“创建Plan”到底做了什么。
/planner/BasicQueryPlanner.java

public class BasicQueryPlanner implements QueryPlanner {
   public Plan createPlan(QueryData data, Transaction tx) {
      //Step 1: Create a plan for each mentioned table or view
      List<Plan> plans = new ArrayList<Plan>();
      for (String tblname : data.tables()) {
         String viewdef = SimpleDB.mdMgr().getViewDef(tblname, tx);
         if (viewdef != null) plans.add(SimpleDB.planner().createQueryPlan(viewdef, tx));
         else plans.add(new TablePlan(tblname, tx)); }
      //Step 2: Create the product of all table plans
      Plan p = plans.remove(0);
      for (Plan nextplan : plans) p = new ProductPlan(p, nextplan);
      //Step 3: Add a selection plan for the predicate
      p = new SelectPlan(p, data.pred());
      //Step 4: Project on the field names
      p = new ProjectPlan(p, data.fields());
      return p;}}

总体来看，createPlan()输入SQL语句的QueryTree（data）以及当前的事务信息（tx），输出一个ProjectPlan类的实例。

首先，递归生成SQL中涉及TablePlan
这一步分别生成SQL中涉及的表的Plan，即是TablePlan

      List<Plan> plans = new ArrayList<Plan>();
      for (String tblname : data.tables()) {
         String viewdef = SimpleDB.mdMgr().getViewDef(tblname, tx);
         if (viewdef != null) plans.add(SimpleDB.planner().createQueryPlan(viewdef, tx));
         else plans.add(new TablePlan(tblname, tx)); }

如果可以查询到tblname相关的视图定义，则递归分析该视图（视图的定义相当于一段select语句），抽取它的最后Plan结果。如果不能查询到相应的视图定义（说明tblname指的是一个table），则为其创建TablePlan类实例。

我们来看TablePlan类是什么，

• tplist <- ArrayList<TablePlan>
  • tblplan <- TablePlan(tblname, tx), it has two members:
    • ti:TableInfo <- SimpleDB.mdMgr().getTableInfo(tblname, tx)
    • si:StatInfo <- SimpleDB.mdMgr().getStatInfo(tblname, ti, tx)
  • Attention to mdMgr
    • mdMgr:metadataMgr <- SimpleDB.mdMgr()
    • mdMgr has 4 members:
      • tblmgr -> getTableInfo():TableInfo & createTable():void
      • statmgr -> getStatInfo():StatInfo
      • idxmgr -> getIndexInfo():Map<String, IndexInfo>
      • viewmgr -> getViewInfo():String (一条SQL语句，描述View的定义)

接下来看ProductPlan完成的工作。
接着将所有的TablePlan类实例进行Product操作。

• ProductPlan(p1:TablePlan, p2:TablePlan)初始化，它包含一个schema:Schema 成员
  • Schema类的数据存储结构是HashMap<String,FieldInfo>
    • key 是 fieldname:String, value 是 FieldInfo
    • FieldInfo类有两个 整型 属性，type & length
  • 初始化时，完成schema.addAll(p1.schema()) & schema.addAll(p2.schema())
    • TablePlan用getTableInfo(tblname,tx)生成 TableInfo(tblname, sch, offsets, reclen)
    • TablePlan的schema()返回sch变量
  • schema.addAll(p.schema()) 只是把p的schema的HashMap数据结构和自己的HashMap合并，
  • 所以这里的操作就是把p1和p2的schema合并

第三步是SelectPlan，完成数据的选择
对Product后生成的一个联合大表进行Selection操作。

• 使用前面生成的Plan类（其实是继承了Plan接口的ProductPlan类）生成SelectPlan类
  • 初始化SelectPlan(p:ProductPlan, data.pred())
  • 这里data:QueryData, data.pred() 返回了一个Predicate类

最后一步是ProjectPlan
记录哪些field需要保留，相当于SQL语句中的“select field1, field2, ...” 部分。

---

约定用语

a->function() a is the real executor of that function
a<-function() a is generated by that function
a:A a is an instance of class A

类的实例
rstmt RemoteStatement //
rrs RemoteResultSet //
pln Plan //
qry String //
tx Transaction //
ti TableInfo
si StatInfo
sch Schema
s Scan