TypeScript Expression.parseSQL方法代码示例

  createJSONServer(port, (parameters: JSONParameters, res: any) => {
    var { sql } = parameters;

    try {
      var sqlParse = Expression.parseSQL(sql);
    } catch (e) {
      res.status(400).send({ error: e.message });
      return;
    }

    if (sqlParse.verb && sqlParse.verb !== 'SELECT') { // DESCRIBE + SHOW get re-written
      res.status(400).send({ error: `Unsupported SQL verb ${sqlParse.verb} must be SELECT, DESCRIBE, SHOW, or a raw expression` });
    }

    executeSQLParse(sqlParse, context, timezone)
      .then((value: PlywoodValue) => {
        if (Dataset.isDataset(value)) {
          res.json({
            result: value.toJS()
          });
        } else {
          res.json({
            result: value
          });
        }
      })
      .fail((e) => {
        res.status(400).send({ error: e.message });
      })
      .done();
  });

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

    Q.fcall(() => {
      var myContext = context;
      var match: string[];

      // Deal with "SELECT @@blah LIMIT 1" by de-sugaring
      if ((/SELECT\s+@@/i).test(sql)) {
        sql = sql.replace(/@@(?:global\.|session\.)?/g, '');
        myContext = {
          data: getVariablesFlatDataset()
        }
      }

      // Hack, treat USE `blah` as SET ... (ignores it)
      if (match = sql.match(/USE\s+`/i)) {
        sql = "SET NAMES 'utf8'";
      }

      // Handle connection id query
      if (match = sql.match(/SELECT\s+(CONNECTION_ID\(\s*\))/i)) {
        return {
          type: 'connectionId',
          name: match[1]
        }
      }

      try {
        var sqlParse = Expression.parseSQL(sql);
      } catch (e) {
        printError(sql, e);
        return {
          type: 'error',
          code: 1064, // You have an error in your SQL syntax
          message: e.message
        };
      }

      if (!sqlParse.verb) {
        return {
          type: 'error',
          code: 1064,
          message: `Must have a verb`
        };
      }

      switch (sqlParse.verb) {
        case 'SET':
          return {
            type: 'ok'
          };

        case 'SELECT':
          return executeSQLParse(sqlParse, myContext, timezone)
            .then((dataset: PlywoodValue): MySQLResult => {
              if (Dataset.isDataset(dataset)) {
                return {
                  type: 'dataset',
                  dataset,
                  table: sqlParse.table
                };
              } else {
                throw new Error('unexpected result from expression');
              }
            });

        default:
          return {
            type: 'error',
            code: 1337,
            message: `Permission to ${sqlParse.verb} denied`
          };
      }
    })

router.post('/', (req: PivotRequest, res: Response) => {
  var { version, outputType, query } = req.body;

  if (version && version !== req.version) {
    res.status(400).send({
      error: 'incorrect version',
      action: 'reload'
    });
    return;
  }

  if (typeof query !== "string") {
    var errmsg = "Query must be a string";
    res.status(400).send(errmsg);
    return;
  }

  try {
    var parsedSQL = Expression.parseSQL(query);
  } catch (e) {
    var errmsg = "Could not parse query as SQL: " + e.message;
    res.status(400).send(errmsg);
    return;
  }

  if (typeof outputType !== "string") {
    outputType = "json";
  }

  var outputFn: (data: Dataset) => string;
  outputFn = outputFunctions[outputType];
  if (outputFn === undefined) {
    var errmsg = "Invalid output type: " + outputType;
    res.status(400).send(errmsg);
    return;
  }

  var parsedQuery = parsedSQL.expression;
  var dataCube = parsedSQL.table;
  if (!dataCube) {
    var errmsg = "Could not determine data cube name";
    res.status(400).send(errmsg);
    return;
  }

  parsedQuery = parsedQuery.substitute((ex) => {
    if (ex instanceof RefExpression && ex.name === dataCube) {
      return $("main");
    }
    return null;
  });

  req.getSettings(dataCube)
    .then((appSettings) => {
      var myDataCube = appSettings.getDataCube(dataCube);

      if (!myDataCube) {
        res.status(400).send({ error: 'unknown data cube' });
        return;
      }

      myDataCube.executor(parsedQuery).then(
        (data: Dataset) => {
          res.type(outputType);
          res.send(outputFn(Dataset.fromJS(data.toJS())));
        },
        (error: Error) => {
          res.status(500).send(`got error ${error.message}`);
        }
      );
    })
    .done();

});