TypeScript plywood.AttributeInfo類代碼示例

/**
 * This function tries to deduce the structure of the dataSource based on the dimensions and measures defined within.
 * It should only be used when for some reason introspection if not available.
 * @param dataSource
 * @returns {Attributes}
 */
function deduceAttributes(dataSource: DataSource): Attributes {
  var attributeJSs: AttributeJSs = [];

  dataSource.dimensions.forEach((dimension) => {
    // ToDo: fix this.
    attributeJSs.push({ name: dimension.name, type: 'STRING' });
  });

  dataSource.measures.forEach((measure) => {
    var expression = measure.expression;
    var references = getReferences(expression);
    var countDistinctReferences = getCountDistinctReferences(expression);
    for (var reference of references) {
      if (reference === 'main') continue;
      if (countDistinctReferences.indexOf(reference) !== -1) {
        attributeJSs.push({ name: reference, special: 'unique' });
      } else {
        attributeJSs.push({ name: reference, type: 'NUMBER' });
      }
    }
  });

  var attributes = AttributeInfo.fromJSs(attributeJSs);
  if (dataSource.options['attributeOverrides']) {
    attributes = AttributeInfo.applyOverrides(attributes, dataSource.options['attributeOverrides']);
  }

  return attributes;
}

    it('adds new dimensions', () => {
      var columns: any = [
        { "name": "__time", "type": "TIME" },
        { "name": "added", "makerAction": { "action": "sum", "expression": { "name": "added", "op": "ref" }}, "type": "NUMBER", "unsplitable": true },
        { "name": "count", "makerAction": { "action": "count"}, "type": "NUMBER", "unsplitable": true },
        { "name": "delta_hist", "special": "histogram", "type": "NUMBER" },
        { "name": "page", "type": "STRING" },
        { "name": "page_unique", "special": "unique", "type": "STRING" }
      ];

      var dataCube1 = dataCube.addAttributes(AttributeInfo.fromJSs(columns));

      expect(dataCube1.toJS().dimensions).to.deep.equal([
        {
          "kind": "time",
          "name": "__time",
          "title": "Time",
          "formula": "$__time"
        },
        {
          "kind": "string",
          "name": "page",
          "title": "Page",
          "formula": "$page"
        }
      ]);

      columns.push({ "name": "channel", "type": "STRING" });
      var dataCube2 = dataCube1.addAttributes(AttributeInfo.fromJSs(columns));

      expect(dataCube2.toJS().dimensions).to.deep.equal([
        {
          "kind": "time",
          "name": "__time",
          "title": "Time",
          "formula": "$__time"
        },
        {
          "kind": "string",
          "name": "page",
          "title": "Page",
          "formula": "$page"
        },
        {
          "kind": "string",
          "name": "channel",
          "title": "Channel",
          "formula": "$channel"
        }
      ]);

    });

 it('works with max', () => {
   var attribute = AttributeInfo.fromJS({
     "name": "unique_page",
     "special": "unique",
     "type": "STRING"
   });
   var measures = Measure.measuresFromAttributeInfo(attribute).map((m => m.toJS()));
   expect(measures).to.deep.equal([
     {
       "expression": {
         "action": {
           "action": "countDistinct",
           "expression": {
             "name": "unique_page",
             "op": "ref"
           }
         },
         "expression": {
           "name": "main",
           "op": "ref"
         },
         "op": "chain"
       },
       "name": "unique_page",
       "title": "Unique Page"
     }
   ]);
 });

 it('works with histogram', () => {
   var attribute = AttributeInfo.fromJS({
     "name": "delta_hist",
     "special": "histogram",
     "type": "NUMBER"
   });
   var measures = Measure.measuresFromAttributeInfo(attribute).map((m => m.toJS()));
   expect(measures).to.deep.equal([]);
 });

export function externalFactory(dataSource: DataSource, druidRequester: Requester.PlywoodRequester<any>, timeout: number, introspectionStrategy: string): Q.Promise<External> {
  var countDistinctReferences: string[] = [];
  if (dataSource.measures) {
    countDistinctReferences = [].concat.apply([], dataSource.measures.toArray().map((measure) => {
      return getCountDistinctReferences(measure.expression);
    }));
  }

  var context = {
    timeout
  };

  if (dataSource.introspection === 'none') {
    return Q(new DruidExternal({
      suppress: true,
      dataSource: dataSource.source,
      timeAttribute: dataSource.timeAttribute.name,
      customAggregations: dataSource.options.customAggregations,
      attributes: AttributeInfo.override(deduceAttributes(dataSource), dataSource.attributeOverrides),
      introspectionStrategy,
      filter: dataSource.subsetFilter,
      context,
      requester: druidRequester
    }));
  } else {
    var introspectedExternalPromise = new DruidExternal({
      suppress: true,
      dataSource: dataSource.source,
      timeAttribute: dataSource.timeAttribute.name,
      attributeOverrides: dataSource.attributeOverrides,
      customAggregations: dataSource.options.customAggregations,
      introspectionStrategy,
      filter: dataSource.subsetFilter,
      context,
      requester: druidRequester
    }).introspect();

    if (!countDistinctReferences) {
      return introspectedExternalPromise;
    }

    return introspectedExternalPromise.then((introspectedExternal) => {
      var attributes = introspectedExternal.attributes;
      for (var attribute of attributes) {
        // This is a metric that should really be a HLL
        if (attribute.type === 'NUMBER' && countDistinctReferences.indexOf(attribute.name) !== -1) {
          introspectedExternal = introspectedExternal.updateAttribute(AttributeInfo.fromJS({
            name: attribute.name,
            special: 'unique'
          }));
        }
      }
      return introspectedExternal;
    });
  }
}

/**
 * This function tries to deduce the structure of the dataSource based on the dimensions and measures defined within.
 * It should only be used when, for some reason, introspection if not available.
 * @param dataSource
 * @returns {Attributes}
 */
function deduceAttributes(dataSource: DataSource): Attributes {
  var attributeJSs: AttributeJSs = [];

  var timeAttribute = dataSource.timeAttribute;
  if (timeAttribute) {
    attributeJSs.push({ name: timeAttribute.name, type: 'TIME' });
  }

  dataSource.dimensions.forEach((dimension) => {
    var expression = dimension.expression;
    if (expression.equals(timeAttribute)) return;
    var references = getReferences(expression);
    for (var reference of references) {
      if (reference === 'main') continue;
      attributeJSs.push({ name: reference, type: 'STRING' });
    }
  });

  dataSource.measures.forEach((measure) => {
    var expression = measure.expression;
    var references = getReferences(expression);
    var countDistinctReferences = getCountDistinctReferences(expression);
    for (var reference of references) {
      if (reference === 'main') continue;
      if (countDistinctReferences.indexOf(reference) !== -1) {
        attributeJSs.push({ name: reference, special: 'unique' });
      } else {
        attributeJSs.push({ name: reference, type: 'NUMBER' });
      }
    }
  });

  var attributes = AttributeInfo.fromJSs(attributeJSs);
  if (dataSource.attributeOverrides.length) {
    attributes = AttributeInfo.override(attributes, dataSource.attributeOverrides);
  }

  return attributes;
}

 return introspectedExternalPromise.then((introspectedExternal) => {
   var attributes = introspectedExternal.attributes;
   for (var attribute of attributes) {
     // This is a metric that should really be a HLL
     if (attribute.type === 'NUMBER' && countDistinctReferences.indexOf(attribute.name) !== -1) {
       introspectedExternal = introspectedExternal.updateAttribute(AttributeInfo.fromJS({
         name: attribute.name,
         special: 'unique'
       }));
     }
   }
   return introspectedExternal;
 });

 it('works with unique', () => {
   var attribute = AttributeInfo.fromJS({
     "name": "unique_page",
     "special": "unique",
     "type": "STRING"
   });
   var measures = Measure.measuresFromAttributeInfo(attribute).map((m => m.toJS()));
   expect(measures).to.deep.equal([
     {
       "name": "unique_page",
       "title": "Unique Page",
       "formula": "$main.countDistinct($unique_page)"
     }
   ]);
 });