plywood
Version:
A query planner and executor
179 lines (178 loc) • 7.32 kB
JavaScript
import { __assign, __awaiter, __extends, __generator } from "tslib";
import { Introspect, QueryResult, SqlColumn, SqlQuery } from 'druid-query-toolkit';
import * as toArray from 'stream-to-array';
import { AttributeInfo } from '../datatypes';
import { DruidDialect } from '../dialect';
import { SqlRefExpression } from '../expressions';
import { dictEqual } from '../helper';
import { External } from './baseExternal';
import { DruidExternal } from './druidExternal';
import { SQLExternal } from './sqlExternal';
var DruidSQLExternal = (function (_super) {
__extends(DruidSQLExternal, _super);
function DruidSQLExternal(parameters) {
var _this = _super.call(this, parameters, new DruidDialect({ attributes: parameters.rawAttributes || parameters.attributes })) || this;
_this._ensureEngine('druidsql');
_this.context = parameters.context;
return _this;
}
DruidSQLExternal.fromJS = function (parameters, requester) {
var value = SQLExternal.jsToValue(parameters, requester);
value.context = parameters.context;
return new DruidSQLExternal(value);
};
DruidSQLExternal.postProcessIntrospect = function (columns) {
return columns.map(function (column) {
var name = column.name;
var effectiveType = column.sqlType === 'TIMESTAMP' || column.sqlType === 'BOOLEAN'
? column.sqlType
: column.nativeType;
var type;
switch (String(effectiveType).toUpperCase()) {
case 'TIMESTAMP':
case 'DATE':
type = 'TIME';
break;
case 'IPADDRESS':
case 'IPPREFIX':
type = 'IP';
break;
case 'VARCHAR':
case 'STRING':
type = 'STRING';
break;
case 'DOUBLE':
case 'FLOAT':
case 'BIGINT':
case 'LONG':
type = 'NUMBER';
break;
case 'BOOLEAN':
type = 'BOOLEAN';
break;
case 'imply-ts':
type = 'TIME_SERIES';
break;
default:
type = 'NULL';
break;
}
return new AttributeInfo({
name: name,
type: type,
nativeType: effectiveType,
});
});
};
DruidSQLExternal.getSourceList = function (requester) {
return __awaiter(this, void 0, void 0, function () {
var sources;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, toArray(requester({
query: {
query: Introspect.getTableIntrospectionQuery(),
},
}))];
case 1:
sources = _a.sent();
return [2, Introspect.decodeTableIntrospectionResult(QueryResult.fromRawResult(sources))
.map(function (s) { return s.name; })
.sort()];
}
});
});
};
DruidSQLExternal.getVersion = function (requester) {
return toArray(requester({
query: {
queryType: 'status',
},
})).then(function (res) {
return res[0].version;
});
};
DruidSQLExternal.prototype.valueOf = function () {
var value = _super.prototype.valueOf.call(this);
value.context = this.context;
return value;
};
DruidSQLExternal.prototype.toJS = function () {
var js = _super.prototype.toJS.call(this);
if (this.context)
js.context = this.context;
return js;
};
DruidSQLExternal.prototype.equals = function (other) {
return _super.prototype.equals.call(this, other) && dictEqual(this.context, other.context);
};
DruidSQLExternal.prototype.getTimeAttribute = function () {
return '__time';
};
DruidSQLExternal.prototype.isTimeRef = function (ex) {
if (ex instanceof SqlRefExpression) {
if (ex.parsedSql instanceof SqlColumn) {
return ex.parsedSql.getName() === '__time';
}
else {
return false;
}
}
else {
return _super.prototype.isTimeRef.call(this, ex);
}
};
DruidSQLExternal.prototype.getIntrospectAttributes = function (depth) {
return __awaiter(this, void 0, void 0, function () {
var _a, source, withQuery, withQueryParsed, queryPayload, rawResult, queryResult, table;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
_a = this, source = _a.source, withQuery = _a.withQuery;
if (!withQuery) return [3, 2];
withQueryParsed = void 0;
try {
withQueryParsed = SqlQuery.parse(withQuery);
}
catch (e) {
throw new Error("could not parse withQuery: ".concat(e.message));
}
queryPayload = Introspect.getQueryColumnIntrospectionPayload(withQueryParsed);
return [4, toArray(this.requester({
query: __assign(__assign({}, queryPayload), { resultFormat: 'array', context: this.context }),
}))];
case 1:
rawResult = _b.sent();
queryResult = QueryResult.fromRawResult(rawResult, true, queryPayload.header, queryPayload.typesHeader, queryPayload.sqlTypesHeader);
return [2, DruidSQLExternal.postProcessIntrospect(Introspect.decodeQueryColumnIntrospectionResult(queryResult))];
case 2:
table = void 0;
if (Array.isArray(source)) {
table = source[0];
}
else {
table = source;
}
return [2, DruidExternal.introspectAttributesWithSegmentMetadata(table, this.requester, '__time', this.context, depth)];
}
});
});
};
DruidSQLExternal.prototype.sqlToQuery = function (sql) {
var payload = {
query: sql,
};
payload.context = __assign(__assign({}, (this.context || {})), { sqlTimeZone: 'Etc/UTC' });
return payload;
};
DruidSQLExternal.prototype.capability = function (cap) {
if (cap === 'filter-on-attribute')
return false;
return _super.prototype.capability.call(this, cap);
};
DruidSQLExternal.engine = 'druidsql';
DruidSQLExternal.type = 'DATASET';
return DruidSQLExternal;
}(SQLExternal));
export { DruidSQLExternal };
External.register(DruidSQLExternal);