Adding more perf regression tests (joins, index cost).

Specifically:
- Adding a new curve in existing SelectSingleRow graph, which
demonstrates current performance pain point in BTree#cost().
- Adding a new graph for joins with curves for theta-join and
equi-join accordingly.
-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=82523214

Author: freshp86

perf/lf_perf_test.js

@@ -257,6 +257,10 @@ function selectRunner(name, db) {
         'SelectSingleRowNonIndexed',
         selectBenchmark.querySingleRowNonIndexed.bind(selectBenchmark),
         selectBenchmark.verifySingleRowNonIndexed.bind(selectBenchmark));
+    benchmarkRunner.schedule(
+        'SelectSingleRowMultipleIndices',
+        selectBenchmark.querySingleRowMultipleIndices.bind(selectBenchmark),
+        selectBenchmark.verifySingleRowMultipleIndices.bind(selectBenchmark));
     benchmarkRunner.schedule(
         'SelectMultiRowIndexedRange',
         selectBenchmark.queryMultiRowIndexedRange.bind(selectBenchmark),
@@ -295,6 +299,14 @@ function selectRunner(name, db) {
         'SelectProjectAggregateNonIndexed',
         selectBenchmark.queryProjectAggregateNonIndexed.bind(selectBenchmark),
         selectBenchmark.verifyProjectAggregateNonIndexed.bind(selectBenchmark));
+    benchmarkRunner.schedule(
+        'SelectJoinEqui',
+        selectBenchmark.queryJoinEqui.bind(selectBenchmark),
+        selectBenchmark.verifyJoinEqui.bind(selectBenchmark));
+    benchmarkRunner.schedule(
+        'SelectJoinTheta',
+        selectBenchmark.queryJoinTheta.bind(selectBenchmark),
+        selectBenchmark.verifyJoinTheta.bind(selectBenchmark));
 
     return benchmarkRunner.run(REPETITIONS);
   }).then(tearDown, tearDown);

testing/hr_schema/mock_data_generator.js

@@ -37,13 +37,13 @@ lf.testing.hrSchema.MockDataGenerator = function(schema) {
   /** @private {!hr.db.schema.Database} */
   this.schema_ = schema;
 
-  /** @type {!Array.<!hr.db.row.Job>} */
+  /** @type {!Array<!hr.db.row.Job>} */
   this.sampleJobs = [];
 
-  /** @type {!Array.<!hr.db.row.Employee>} */
+  /** @type {!Array<!hr.db.row.Employee>} */
   this.sampleEmployees = [];
 
-  /** @type {!Array.<!hr.db.row.Department>} */
+  /** @type {!Array<!hr.db.row.Department>} */
   this.sampleDepartments = [];
 
   /** @type {!lf.testing.hrSchema.MockDataGenerator.JobGroundTruth} */
@@ -63,7 +63,8 @@ lf.testing.hrSchema.MockDataGenerator = function(schema) {
  *   countSalary: number,
  *   minHireDate: !Date,
  *   maxHireDate: !Date,
- *   employeesPerJob: !goog.labs.structs.Multimap<string, string>
+ *   employeesPerJob: !goog.labs.structs.Multimap<string, string>,
+ *   thetaJoinSalaryIds: !Array<string>
  * }}
  */
 lf.testing.hrSchema.MockDataGenerator.EmployeeGroundTruth;
@@ -73,13 +74,13 @@ lf.testing.hrSchema.MockDataGenerator.EmployeeGroundTruth;
  * @typedef {{
  *   minMinSalary: number,
  *   maxMinSalary: number,
- *   distinctMinSalary: !Array.<number>,
+ *   distinctMinSalary: !Array<number>,
  *   countDistinctMinSalary: number,
  *   avgDistinctMinSalary: number,
  *   stddevDistinctMinSalary: number,
  *   minMaxSalary: number,
  *   maxMaxSalary: number,
- *   distinctMaxSalary: !Array.<number>,
+ *   distinctMaxSalary: !Array<number>,
  *   countDistinctMaxSalary: number,
  *   avgDistinctMaxSalary: number,
  *   stddevDistinctMaxSalary: number,
@@ -172,7 +173,8 @@ lf.testing.hrSchema.MockDataGenerator.prototype.extractEmployeeGroundTruth_ =
         null, this.sampleEmployees.map(salary)),
     countSalary: 0,
     minHireDate: this.findEmployeeMinDate_(),
-    maxHireDate: this.findEmployeeMaxDate_()
+    maxHireDate: this.findEmployeeMaxDate_(),
+    thetaJoinSalaryIds: this.findThetaJoinSalaryIds_()
   };
 };
 
@@ -211,7 +213,7 @@ lf.testing.hrSchema.MockDataGenerator.prototype.findJobMax_ = function(
  * Finds the DISTINCT of a given attribute in the Job table.
  * @param {!function(!hr.db.row.Job): number} getterFn The function to call for
  *     accessing the attribute of interest.
- * @return {!Array.<number>} The distinct values.
+ * @return {!Array<number>} The distinct values.
  * @private
  */
 lf.testing.hrSchema.MockDataGenerator.prototype.findJobDistinct_ = function(
@@ -310,6 +312,33 @@ lf.testing.hrSchema.MockDataGenerator.prototype.findEmployeeMaxDate_ =
 };
 
 
+/**
+ * Finds the IDs of all employees whose salary is larger than the MAX salary for
+ * their job title.
+ * Note: This is possible because generated employee data does not respect
+ * corresponding min/max job salary.
+ * @return {!Array<string>} The employee IDs in ascending sorted order.
+ * @private
+ */
+lf.testing.hrSchema.MockDataGenerator.prototype.findThetaJoinSalaryIds_ =
+    function() {
+  var employeeIds = [];
+
+  for (var i = 0; i < this.sampleEmployees.length; i++) {
+    for (var j = 0; j < this.sampleJobs.length; j++) {
+      var employee = this.sampleEmployees[i];
+      var job = this.sampleJobs[j];
+      if (employee.getJobId() == job.getId() &&
+          employee.getSalary() > job.getMaxSalary()) {
+        employeeIds.push(employee.getId());
+      }
+    }
+  }
+
+  return employeeIds.sort();
+};
+
+
 /**
  * @typedef {{
  *   departments: !Array<!hr.db.row.DepartmentDbType>,

testing/perf/select_benchmark.js

@@ -19,6 +19,7 @@ goog.provide('lf.testing.perf.SelectBenchmark');
 goog.require('goog.math');
 goog.require('lf.Order');
 goog.require('lf.fn');
+goog.require('lf.op');
 
 
 
@@ -209,6 +210,50 @@ lf.testing.perf.SelectBenchmark.prototype.querySingleRowNonIndexed =
 };
 
 
+/**
+ * Note: The following query uses two ValuePredicates that both operate on an
+ * indexed property. This causes the IndexRangeScanPass to select the most
+ * selective index for the IndexRangeScan step by calling BTree#cost(), and
+ * because of the TODO that exists in that method performance is very poor.
+ * Should observe a noticeable change once BTree#cost() is optimized.
+ *
+ * @return {!IThenable}
+ */
+lf.testing.perf.SelectBenchmark.prototype.querySingleRowMultipleIndices =
+    function() {
+  // Selecting a value purposefully high such that all rows satisfy this
+  // predicate, whereas the other predicate is satisfied by only one row.
+  var salaryThreshold = 2 * this.dataGenerator_.employeeGroundTruth.avgSalary;
+
+  var q = this.db_.
+      select().
+      from(this.e_).
+      orderBy(this.e_.id, lf.Order.ASC).
+      where(lf.op.and(
+          this.e_.id.eq(this.queryData_.employeeId),
+          this.e_.salary.lt(salaryThreshold)));
+
+  return q.exec();
+};
+
+
+/**
+ * @param {!Array.<!Object>} results
+ * @return {!IThenable.<boolean>}
+ */
+lf.testing.perf.SelectBenchmark.prototype.verifySingleRowMultipleIndices =
+    function(results) {
+  var salaryThreshold = 2 * this.dataGenerator_.employeeGroundTruth.avgSalary;
+
+  var validated = results.every(function(obj) {
+    return obj[this.e_.id.getName()] == this.queryData_.employeeId &&
+        obj[this.e_.salary.getName()] < salaryThreshold;
+  }, this);
+
+  return goog.Promise.resolve(validated);
+};
+
+
 /**
  * @param {!Array.<!Object>} results
  * @return {!IThenable.<boolean>}
@@ -528,3 +573,61 @@ lf.testing.perf.SelectBenchmark.prototype.verifyProjectAggregateNonIndexed =
 
   return goog.Promise.resolve(validated);
 };
+
+
+/** @return {!IThenable} */
+lf.testing.perf.SelectBenchmark.prototype.queryJoinEqui = function() {
+  return this.db_.
+      select().
+      from(this.e_, this.j_).
+      where(this.e_.jobId.eq(this.j_.id)).
+      exec();
+};
+
+
+/**
+ * @param {!Array.<!Object>} results
+ * @return {!IThenable.<boolean>}
+ */
+lf.testing.perf.SelectBenchmark.prototype.verifyJoinEqui = function(results) {
+  if (this.dataGenerator_.sampleEmployees.length != results.length) {
+    return goog.Promise.resolve(false);
+  }
+
+  var validated = results.every(function(obj) {
+    return goog.object.getCount(obj) == 2 &&
+        goog.isDefAndNotNull(obj[this.e_.getName()]) &&
+        goog.isDefAndNotNull(obj[this.j_.getName()]) &&
+        obj[this.e_.getName()][this.e_.jobId.getName()] ==
+            obj[this.j_.getName()][this.j_.id.getName()];
+  }, this);
+
+  return goog.Promise.resolve(validated);
+};
+
+
+/** @return {!IThenable} */
+lf.testing.perf.SelectBenchmark.prototype.queryJoinTheta = function() {
+  return this.db_.
+      select().
+      from(this.j_, this.e_).
+      orderBy(this.e_.id, lf.Order.ASC).
+      where(lf.op.and(
+          this.e_.jobId.eq(this.j_.id),
+          this.e_.salary.gt(this.j_.maxSalary))).
+      exec();
+};
+
+
+/**
+ * @param {!Array.<!Object>} results
+ * @return {!IThenable.<boolean>}
+ */
+lf.testing.perf.SelectBenchmark.prototype.verifyJoinTheta = function(results) {
+  var validated = results.every(function(obj, i) {
+    return obj[this.e_.getName()][this.e_.id.getName()] ==
+        this.dataGenerator_.employeeGroundTruth.thetaJoinSalaryIds[i];
+  }, this);
+
+  return goog.Promise.resolve(validated);
+};