TypeScript plywood.AttributeJSs类代码示例

/**
 * 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;
}

export function run() {
  var parsed = parseArgs();

  if (parsed.argv.original.length === 0 || parsed['help']) {
    printUsage();
    return;
  }

  if (parsed['version']) {
    printVersion();
    return;
  }

  var verbose: boolean = parsed['verbose'];

  // Get allow
  var allows: string[] = parsed['allow'] || [];
  for (let allow of allows) {
    if (!(allow === 'eternity' || allow === 'select')) {
      console.log("Unexpected allow", allow);
      return;
    }
  }

  // Get forced attribute overrides
  var attributeOverrides: AttributeJSs = [];
  var forceUnique: string[] = parsed['force-unique'] || [];
  for (let attributeName of forceUnique) {
    attributeOverrides.push({ name: attributeName, special: 'unique' });
  }
  var forceHistogram: string[] = parsed['force-histogram'] || [];
  for (let attributeName of forceHistogram) {
    attributeOverrides.push({ name: attributeName, special: 'histogram' });
  }

  // Get output
  var output: string = (parsed['output'] || 'json').toLowerCase();
  if (output !== 'json' && output !== 'csv' && output !== 'tsv' && output !== 'flat') {
    console.log(`output must be one of json, csv, tsv, or flat (is ${output}})`);
    return;
  }

  // Get host
  var host: string = parsed['druid'] || parsed['host'];
  if (!host) {
    console.log("must have a host");
    return;
  }

  // Get SQL
  var query: string = parsed['query'];
  if (query) {
    try {
      var sqlParse = Expression.parseSQL(query);
    } catch (e) {
      console.log("Could not parse query as SQL:", e.message);
      return;
    }

    if (sqlParse.verb !== 'SELECT' && sqlParse.verb !== 'DESCRIBE') {
      console.log("SQL must be a SELECT or DESCRIBE query");
      return;
    }
  } else {
    console.log("no query found please use --query (-q) flag");
    return;
  }

  var expression = sqlParse.expression;

  if (verbose) {
    console.log('Parsed query as the following plywood expression (as JSON):');
    console.log(JSON.stringify(expression, null, 2));
    console.log('---------------------------');
  }

  var dataName = 'data';
  var dataSource: string;
  if (parsed['data-source']) {
    dataSource = parsed['data-source'];
  } else if (sqlParse.table) {
    dataName = sqlParse.table;
    dataSource = sqlParse.table;
  } else {
    console.log("must have data source");
    return;
  }

  var timeout: number = parsed.hasOwnProperty('timeout') ? parsed['timeout'] : 60000;

  var requester: Requester.PlywoodRequester<any>;
  requester = druidRequesterFactory({
    host: host,
    timeout
  });

  var retry: number = parsed.hasOwnProperty('retry') ? parsed['retry'] : 2;
  if (retry > 0) {
    requester = helper.retryRequesterFactory({
      requester: requester,
//.........这里部分代码省略.........