TypeScript plywood-druid-requester.druidRequesterFactory函数代码示例

export function properDruidRequesterFactory(options: ProperDruidRequesterOptions): Requester.PlywoodRequester<any> {
  var {
    druidHost,
    retry,
    timeout,
    verbose,
    concurrentLimit,
    requestDecorator
  } = options;

  var druidRequester = druidRequesterFactory({
    host: druidHost,
    timeout: timeout || 30000,
    requestDecorator
  });

  if (retry) {
    druidRequester = helper.retryRequesterFactory({
      requester: druidRequester,
      retry: retry,
      delay: 500,
      retryOnTimeout: false
    });
  }

  if (verbose) {
    druidRequester = helper.verboseRequesterFactory({
      requester: druidRequester
    });
  }

  if (concurrentLimit) {
    druidRequester = helper.concurrentLimitRequesterFactory({
      requester: druidRequester,
      concurrentLimit: concurrentLimit
    });
  }

  return druidRequester;
}

export function properRequesterFactory(options: ProperRequesterOptions): Requester.PlywoodRequester<any> {
  var {
    type,
    host,
    retry,
    timeout,
    verbose,
    concurrentLimit
  } = options;

  var requester: Requester.PlywoodRequester<any>;

  switch (type) {
    case 'druid':
      requester = druidRequesterFactory({
        host,
        timeout: timeout || 30000,
        requestDecorator: options.druidRequestDecorator
      });
      break;

    case 'mysql':
      requester = mySqlRequesterFactory({
        host,
        database: options.database,
        user: options.user,
        password: options.password
      });
      break;

    case 'postgres':
      requester = postgresRequesterFactory({
        host,
        database: options.database,
        user: options.user,
        password: options.password
      });
      break;

    default:
      throw new Error(`unknown requester type ${type}`);
  }

  if (retry) {
    requester = helper.retryRequesterFactory({
      requester: requester,
      retry: retry,
      delay: 500,
      retryOnTimeout: false
    });
  }

  if (verbose) {
    requester = helper.verboseRequesterFactory({
      requester: requester
    });
  }

  if (concurrentLimit) {
    requester = helper.concurrentLimitRequesterFactory({
      requester: requester,
      concurrentLimit: concurrentLimit
    });
  }

  return requester;
}

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,
//.........这里部分代码省略.........