Function stratify

src/runtime/builder.ts:576–734

(scans)

}

function stratify(scans) {
  if(!scans.length) return [new BlockStratum([], [])];

  let aggregates = [];
  let variableInfo = {};
  let blockLevel = {};

  let provide = (variable, scan) => {
    if(join.isVariable(variable)) {
      let info = variableInfo[variable.id]
      if(!info) {
        info = variableInfo[variable.id] = {providers: []};
      }
      info.providers.push(scan);
    }
  }

  let maybeLevelVariable = (scan, level, variable) => {
    if(join.isVariable(variable)) {
      let info = variableInfo[variable.id]
      let minLevel = level;
      for(let provider of info.providers) {
        let providerLevel = blockLevel[provider.id] || 0;
        minLevel = Math.min(minLevel, providerLevel);
      }
      info.level = minLevel;
    }
  }

  for(let scan of scans) {
    if(scan instanceof join.Scan) {
      provide(scan.e, scan);
      provide(scan.a, scan);
      provide(scan.v, scan);
    } else if(scan instanceof Aggregate || scan instanceof Sort) {
      aggregates.push(scan);
      blockLevel[scan.id] = 1;
      for(let ret of scan.returns) {
        provide(ret, scan);
      }
    } else if(scan instanceof join.Constraint) {
      for(let ret of scan.returns) {
        provide(ret, scan);
      }
    } else if(scan instanceof join.IfScan) {
      for(let output of scan.outputs) {
        provide(output, scan);
      }
    } else if(scan instanceof join.NotScan) {
      // not can never provide a variable, so there's nothing
      // we need to do here
    }
  }

  // Before we start to stratify, we need to run through all the aggregates
  // to determine what level their returns should be at. If the aggregate is
  // the only provider for the return, then it should be at the same level as
  // the aggregate itself. If, however, there are other scans that provide the