@l-v-yonsama/multi-platform-database-drivers 2.0.1 → 2.1.0

package/built/src/drivers/providers/performance/dynamoPartiqlAccessPattern.js

@@ -0,0 +1,736 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDynamoPartiqlTarget = extractDynamoPartiqlTarget;
+exports.analyzeDynamoPartiqlAccessPattern = analyzeDynamoPartiqlAccessPattern;
+exports.analyzeDynamoNativeQueryAccessPattern = analyzeDynamoNativeQueryAccessPattern;
+const PUNCT_2 = new Set(['<=', '>=', '<>', '!=']);
+const PUNCT_1 = new Set([
+    '(',
+    ')',
+    '[',
+    ']',
+    ',',
+    '.',
+    '=',
+    '<',
+    '>',
+    '*',
+    ';',
+]);
+function tokenize(sql, allowNamedParam = false) {
+    const tokens = [];
+    const n = sql.length;
+    let i = 0;
+    while (i < n) {
+        const ch = sql[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (ch === '-' && sql[i + 1] === '-') {
+            while (i < n && sql[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && sql[i + 1] === '*') {
+            const close = sql.indexOf('*/', i + 2);
+            if (close === -1)
+                return undefined;
+            i = close + 2;
+            continue;
+        }
+        if (ch === "'") {
+            const end = readQuoted(sql, i, "'");
+            if (end === undefined)
+                return undefined;
+            tokens.push({ type: 'string', value: '' });
+            i = end;
+            continue;
+        }
+        if (ch === '"') {
+            const end = readQuoted(sql, i, '"');
+            if (end === undefined)
+                return undefined;
+            tokens.push({
+                type: 'qident',
+                value: unescapeQuoted(sql.slice(i + 1, end - 1), '"'),
+            });
+            i = end;
+            continue;
+        }
+        if (ch === '?') {
+            tokens.push({ type: 'param', value: '?' });
+            i++;
+            continue;
+        }
+        if (ch === ':' && allowNamedParam) {
+            const m = /^:[A-Za-z_][A-Za-z0-9_]*/.exec(sql.slice(i));
+            if (!m)
+                return undefined;
+            tokens.push({ type: 'param', value: m[0] });
+            i += m[0].length;
+            continue;
+        }
+        if (ch === '#' && allowNamedParam) {
+            const m = /^#[A-Za-z_][A-Za-z0-9_]*/.exec(sql.slice(i));
+            if (!m)
+                return undefined;
+            tokens.push({ type: 'ident', value: m[0] });
+            i += m[0].length;
+            continue;
+        }
+        if (/[0-9]/.test(ch)) {
+            const m = /^\d+(\.\d+)?/.exec(sql.slice(i));
+            tokens.push({ type: 'number', value: m[0] });
+            i += m[0].length;
+            continue;
+        }
+        if (/[A-Za-z_]/.test(ch)) {
+            const m = /^[A-Za-z_][A-Za-z0-9_]*/.exec(sql.slice(i));
+            tokens.push({ type: 'ident', value: m[0] });
+            i += m[0].length;
+            continue;
+        }
+        const two = sql.slice(i, i + 2);
+        if (PUNCT_2.has(two)) {
+            tokens.push({ type: 'punct', value: two === '!=' ? '<>' : two });
+            i += 2;
+            continue;
+        }
+        if (PUNCT_1.has(ch)) {
+            tokens.push({ type: 'punct', value: ch });
+            i++;
+            continue;
+        }
+        return undefined;
+    }
+    tokens.push({ type: 'eof', value: '' });
+    return tokens;
+}
+function readQuoted(sql, start, quoteChar) {
+    let i = start + 1;
+    const n = sql.length;
+    while (i < n) {
+        if (sql[i] === quoteChar) {
+            if (sql[i + 1] === quoteChar) {
+                i += 2;
+                continue;
+            }
+            return i + 1;
+        }
+        i++;
+    }
+    return undefined;
+}
+function unescapeQuoted(raw, quoteChar) {
+    return raw.split(quoteChar + quoteChar).join(quoteChar);
+}
+class ParseError extends Error {
+}
+class TokenCursor {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.pos = 0;
+    }
+    peek(offset = 0) {
+        return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];
+    }
+    next() {
+        const t = this.peek();
+        if (t.type !== 'eof')
+            this.pos++;
+        return t;
+    }
+    atEnd() {
+        return this.peek().type === 'eof';
+    }
+    isKeyword(word, offset = 0) {
+        const t = this.peek(offset);
+        return t.type === 'ident' && t.value.toUpperCase() === word;
+    }
+    expectKeyword(word) {
+        if (!this.isKeyword(word)) {
+            throw new ParseError(`expected ${word}`);
+        }
+        this.next();
+    }
+    isPunct(value, offset = 0) {
+        const t = this.peek(offset);
+        return t.type === 'punct' && t.value === value;
+    }
+    expectPunct(value) {
+        if (!this.isPunct(value)) {
+            throw new ParseError(`expected '${value}'`);
+        }
+        this.next();
+    }
+}
+function parsePath(c) {
+    const t = c.peek();
+    if (t.type !== 'ident' && t.type !== 'qident') {
+        return undefined;
+    }
+    c.next();
+    const segments = [t.value];
+    for (;;) {
+        if (c.isPunct('.')) {
+            c.next();
+            const seg = c.peek();
+            if (seg.type !== 'ident' && seg.type !== 'qident') {
+                throw new ParseError('expected identifier after .');
+            }
+            c.next();
+            segments.push(seg.value);
+            continue;
+        }
+        if (c.isPunct('[')) {
+            c.next();
+            if (c.peek().type !== 'number') {
+                throw new ParseError('expected numeric array index');
+            }
+            c.next();
+            c.expectPunct(']');
+            continue;
+        }
+        break;
+    }
+    return segments;
+}
+function skipValue(c) {
+    const t = c.peek();
+    if (t.type === 'string' || t.type === 'number' || t.type === 'param') {
+        c.next();
+        return;
+    }
+    if (c.isPunct('[')) {
+        c.next();
+        if (!c.isPunct(']')) {
+            skipValue(c);
+            while (c.isPunct(',')) {
+                c.next();
+                skipValue(c);
+            }
+        }
+        c.expectPunct(']');
+        return;
+    }
+    if (t.type === 'ident' || t.type === 'qident') {
+        parsePath(c);
+        if (c.isPunct('(')) {
+            c.next();
+            if (!c.isPunct(')')) {
+                skipValue(c);
+                while (c.isPunct(',')) {
+                    c.next();
+                    skipValue(c);
+                }
+            }
+            c.expectPunct(')');
+        }
+        return;
+    }
+    throw new ParseError('expected value');
+}
+function skipValueList(c) {
+    skipValue(c);
+    while (c.isPunct(',')) {
+        c.next();
+        skipValue(c);
+    }
+}
+const COMPARE_PUNCT = {
+    '=': '=',
+    '<>': '<>',
+    '<': '<',
+    '<=': '<=',
+    '>': '>',
+    '>=': '>=',
+};
+function parsePredicate(c) {
+    const startsWithPath = c.peek().type === 'ident' || c.peek().type === 'qident';
+    if (!startsWithPath) {
+        throw new ParseError('expected predicate');
+    }
+    const path = parsePath(c);
+    if (path === undefined) {
+        throw new ParseError('expected predicate');
+    }
+    const attribute = path.length === 1 ? path[0] : path[0];
+    if (c.isPunct('(')) {
+        const fnName = path.length === 1 ? path[0].toLowerCase() : undefined;
+        c.next();
+        if (fnName === 'begins_with') {
+            const argPath = parsePathOrThrow(c);
+            c.expectPunct(',');
+            skipValue(c);
+            c.expectPunct(')');
+            return { kind: 'compare', attribute: argPath[0], op: 'begins_with' };
+        }
+        if (!c.isPunct(')')) {
+            skipValue(c);
+            while (c.isPunct(',')) {
+                c.next();
+                skipValue(c);
+            }
+        }
+        c.expectPunct(')');
+        return maybeTrailingComparison(c, undefined);
+    }
+    return maybeTrailingComparison(c, attribute);
+}
+function parsePathOrThrow(c) {
+    const path = parsePath(c);
+    if (path === undefined) {
+        throw new ParseError('expected identifier');
+    }
+    return path;
+}
+function maybeTrailingComparison(c, attribute) {
+    let negated = false;
+    if (c.isKeyword('NOT')) {
+        negated = true;
+        c.next();
+    }
+    if (c.isKeyword('BETWEEN')) {
+        c.next();
+        skipValue(c);
+        c.expectKeyword('AND');
+        skipValue(c);
+        return {
+            kind: 'compare',
+            attribute,
+            op: negated ? 'NOT_BETWEEN' : 'BETWEEN',
+        };
+    }
+    if (c.isKeyword('IN')) {
+        c.next();
+        const closer = c.isPunct('[') ? ']' : ')';
+        c.expectPunct(closer === ']' ? '[' : '(');
+        if (!c.isPunct(closer)) {
+            skipValueList(c);
+        }
+        c.expectPunct(closer);
+        return { kind: 'compare', attribute, op: negated ? 'NOT_IN' : 'IN' };
+    }
+    if (negated) {
+        throw new ParseError('unsupported NOT predicate');
+    }
+    const opToken = c.peek();
+    if (opToken.type === 'punct' && opToken.value in COMPARE_PUNCT) {
+        c.next();
+        skipValue(c);
+        return { kind: 'compare', attribute, op: COMPARE_PUNCT[opToken.value] };
+    }
+    if (attribute === undefined) {
+        return { kind: 'other' };
+    }
+    throw new ParseError('expected comparison operator');
+}
+function parseNot(c) {
+    if (c.isKeyword('NOT')) {
+        c.next();
+        return { kind: 'not', child: parseNot(c) };
+    }
+    if (c.isPunct('(')) {
+        c.next();
+        const inner = parseOr(c);
+        c.expectPunct(')');
+        return inner;
+    }
+    return parsePredicate(c);
+}
+function parseAnd(c) {
+    const children = [parseNot(c)];
+    while (c.isKeyword('AND')) {
+        c.next();
+        children.push(parseNot(c));
+    }
+    return children.length === 1 ? children[0] : { kind: 'and', children };
+}
+function parseOr(c) {
+    const children = [parseAnd(c)];
+    while (c.isKeyword('OR')) {
+        c.next();
+        children.push(parseAnd(c));
+    }
+    return children.length === 1 ? children[0] : { kind: 'or', children };
+}
+function parseTableRef(c) {
+    const first = c.peek();
+    if (first.type !== 'ident' && first.type !== 'qident') {
+        throw new ParseError('expected table name');
+    }
+    c.next();
+    if (c.isPunct('.')) {
+        c.next();
+        const second = c.peek();
+        if (second.type !== 'ident' && second.type !== 'qident') {
+            throw new ParseError('expected index name');
+        }
+        c.next();
+        return { tableName: first.value, indexName: second.value };
+    }
+    return { tableName: first.value };
+}
+function parseProjection(c) {
+    if (c.isPunct('*')) {
+        c.next();
+        return { mode: 'allAttributes', allAttributes: true, attributes: [] };
+    }
+    const attributes = [];
+    for (;;) {
+        const path = parsePathOrThrow(c);
+        attributes.push(path.join('.'));
+        if (c.isKeyword('AS')) {
+            c.next();
+            parsePathOrThrow(c);
+        }
+        if (c.isPunct(',')) {
+            c.next();
+            continue;
+        }
+        break;
+    }
+    return { mode: 'specific', allAttributes: false, attributes };
+}
+function parseDynamoPartiqlSelect(sql) {
+    if (typeof sql !== 'string' || sql.trim() === '') {
+        return undefined;
+    }
+    const tokens = tokenize(sql);
+    if (!tokens) {
+        return undefined;
+    }
+    const c = new TokenCursor(tokens);
+    try {
+        c.expectKeyword('SELECT');
+        const projection = parseProjection(c);
+        c.expectKeyword('FROM');
+        const { tableName, indexName } = parseTableRef(c);
+        let where;
+        if (c.isKeyword('WHERE')) {
+            c.next();
+            where = parseOr(c);
+        }
+        let scanForward;
+        if (c.isKeyword('ORDER')) {
+            c.next();
+            c.expectKeyword('BY');
+            parsePathOrThrow(c);
+            if (c.isKeyword('ASC')) {
+                c.next();
+                scanForward = true;
+            }
+            else if (c.isKeyword('DESC')) {
+                c.next();
+                scanForward = false;
+            }
+        }
+        let limit;
+        if (c.isKeyword('LIMIT')) {
+            c.next();
+            const t = c.peek();
+            if (t.type !== 'number') {
+                throw new ParseError('expected LIMIT value');
+            }
+            c.next();
+            limit = Number(t.value);
+        }
+        if (c.isPunct(';')) {
+            c.next();
+        }
+        if (!c.atEnd()) {
+            throw new ParseError('unexpected trailing content');
+        }
+        return { tableName, indexName, projection, where, limit, scanForward };
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+function guaranteesKeyEquality(node, attrName) {
+    switch (node.kind) {
+        case 'and':
+            return node.children.some((child) => guaranteesKeyEquality(child, attrName));
+        case 'or':
+            return (node.children.length > 0 &&
+                node.children.every((child) => guaranteesKeyEquality(child, attrName)));
+        case 'not':
+            return false;
+        case 'compare':
+            return (node.attribute === attrName && (node.op === '=' || node.op === 'IN'));
+        case 'other':
+            return false;
+    }
+}
+const REPORTABLE_SORT_OPS = new Set([
+    '=',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    'BETWEEN',
+    'begins_with',
+]);
+function toReportableOp(op) {
+    return REPORTABLE_SORT_OPS.has(op)
+        ? op
+        : undefined;
+}
+function findFirstComparison(node, attrName) {
+    switch (node.kind) {
+        case 'and':
+        case 'or':
+            for (const child of node.children) {
+                const found = findFirstComparison(child, attrName);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        case 'not':
+            return findFirstComparison(node.child, attrName);
+        case 'compare':
+            return node.attribute === attrName ? node.op : undefined;
+        case 'other':
+            return undefined;
+    }
+}
+function collectAttributes(node, into) {
+    switch (node.kind) {
+        case 'and':
+        case 'or':
+            node.children.forEach((child) => collectAttributes(child, into));
+            return;
+        case 'not':
+            collectAttributes(node.child, into);
+            return;
+        case 'compare':
+            if (node.attribute !== undefined)
+                into.add(node.attribute);
+            return;
+        case 'other':
+            return;
+    }
+}
+function resolveAttributeNames(node, names) {
+    var _a;
+    if (!names)
+        return node;
+    switch (node.kind) {
+        case 'and':
+            return {
+                kind: 'and',
+                children: node.children.map((child) => resolveAttributeNames(child, names)),
+            };
+        case 'or':
+            return {
+                kind: 'or',
+                children: node.children.map((child) => resolveAttributeNames(child, names)),
+            };
+        case 'not':
+            return { kind: 'not', child: resolveAttributeNames(node.child, names) };
+        case 'compare':
+            if ((_a = node.attribute) === null || _a === void 0 ? void 0 : _a.startsWith('#')) {
+                const resolved = names[node.attribute];
+                if (resolved !== undefined) {
+                    return Object.assign(Object.assign({}, node), { attribute: resolved });
+                }
+            }
+            return node;
+        case 'other':
+            return node;
+    }
+}
+function classify(params) {
+    var _a;
+    const { keySchema, tableName, indexName, indexType, projection, consistentRead, limit, resultItemLimit, scanForward, where, } = params;
+    const pkAttr = keySchema.partitionKey.attributeName;
+    const skAttr = (_a = keySchema.sortKey) === null || _a === void 0 ? void 0 : _a.attributeName;
+    const isQuery = where !== undefined && guaranteesKeyEquality(where, pkAttr);
+    const accessPath = isQuery
+        ? indexName
+            ? 'indexQuery'
+            : 'tableQuery'
+        : indexName
+            ? 'indexScan'
+            : 'tableScan';
+    const allAttrs = new Set();
+    if (where)
+        collectAttributes(where, allAttrs);
+    const filterAttrs = new Set(allAttrs);
+    const partitionKey = {
+        attributeName: pkAttr,
+        operator: undefined,
+        conditionPresent: false,
+    };
+    const sortKey = skAttr
+        ? {
+            attributeName: skAttr,
+            operator: undefined,
+            conditionPresent: false,
+        }
+        : undefined;
+    if (where) {
+        const pkOp = findFirstComparison(where, pkAttr);
+        if (pkOp) {
+            partitionKey.conditionPresent = true;
+            if (pkOp === '=' || pkOp === 'IN')
+                partitionKey.operator = pkOp;
+        }
+        if (skAttr && sortKey) {
+            const skOp = findFirstComparison(where, skAttr);
+            if (skOp) {
+                sortKey.conditionPresent = true;
+                sortKey.operator = toReportableOp(skOp);
+            }
+        }
+    }
+    if (isQuery) {
+        filterAttrs.delete(pkAttr);
+        if (skAttr)
+            filterAttrs.delete(skAttr);
+    }
+    return {
+        operation: params.operation,
+        accessPath,
+        confidence: 'certain',
+        tableName,
+        indexName,
+        indexType,
+        partitionKey,
+        sortKey,
+        postReadFilter: {
+            present: filterAttrs.size > 0,
+            attributes: [...filterAttrs],
+        },
+        projection,
+        consistentRead,
+        limit,
+        resultItemLimit,
+        scanForward,
+    };
+}
+function unknownAccessPattern(params) {
+    return {
+        operation: params.operation,
+        accessPath: 'unknown',
+        confidence: 'unknown',
+        tableName: params.tableName,
+        indexName: params.indexName,
+        indexType: params.indexType,
+        postReadFilter: { present: false, attributes: [] },
+        projection: { mode: 'allAttributes', allAttributes: true, attributes: [] },
+        consistentRead: params.consistentRead,
+    };
+}
+function extractDynamoPartiqlTarget(sql) {
+    const parsed = parseDynamoPartiqlSelect(sql);
+    if (!parsed)
+        return undefined;
+    return { tableName: parsed.tableName, indexName: parsed.indexName };
+}
+function analyzeDynamoPartiqlAccessPattern(params) {
+    var _a;
+    const consistentRead = (_a = params.consistentRead) !== null && _a !== void 0 ? _a : 'unknown';
+    const parsed = parseDynamoPartiqlSelect(params.sql);
+    if (!parsed) {
+        return unknownAccessPattern({
+            operation: 'PartiQLSelect',
+            tableName: params.tableName,
+            indexName: params.indexName,
+            indexType: params.indexType,
+            consistentRead,
+        });
+    }
+    return classify({
+        operation: 'PartiQLSelect',
+        where: parsed.where,
+        keySchema: params.keySchema,
+        tableName: params.tableName,
+        indexName: params.indexName,
+        indexType: params.indexType,
+        projection: parsed.projection,
+        consistentRead,
+        limit: parsed.limit,
+        scanForward: parsed.scanForward,
+    });
+}
+function analyzeDynamoNativeQueryAccessPattern(params) {
+    var _a;
+    const { input, keySchema, indexType } = params;
+    const consistentRead = input.consistentRead
+        ? 'strong'
+        : 'eventual';
+    const keyTokens = tokenize((_a = input.keyConditionExpression) !== null && _a !== void 0 ? _a : '', true);
+    if (!keyTokens) {
+        return unknownAccessPattern({
+            operation: 'Query',
+            tableName: input.tableName,
+            indexName: input.indexName,
+            indexType,
+            consistentRead,
+        });
+    }
+    let keyWhere;
+    try {
+        const c = new TokenCursor(keyTokens);
+        keyWhere = resolveAttributeNames(parseOr(c), input.expressionAttributeNames);
+        if (!c.atEnd())
+            throw new ParseError('unexpected trailing content');
+    }
+    catch (_b) {
+        return unknownAccessPattern({
+            operation: 'Query',
+            tableName: input.tableName,
+            indexName: input.indexName,
+            indexType,
+            consistentRead,
+        });
+    }
+    const classified = classify({
+        operation: 'Query',
+        where: keyWhere,
+        keySchema,
+        tableName: input.tableName,
+        indexName: input.indexName,
+        indexType,
+        projection: input.projectionExpression
+            ? {
+                mode: 'specific',
+                allAttributes: false,
+                attributes: input.projectionExpression
+                    .split(',')
+                    .map((s) => s.trim())
+                    .map((attribute) => { var _a, _b; return (_b = (_a = input.expressionAttributeNames) === null || _a === void 0 ? void 0 : _a[attribute]) !== null && _b !== void 0 ? _b : attribute; }),
+            }
+            : input.select === 'ALL_ATTRIBUTES' || !input.indexName
+                ? { mode: 'allAttributes', allAttributes: true, attributes: [] }
+                : {
+                    mode: 'allProjectedAttributes',
+                    allAttributes: false,
+                    attributes: [],
+                },
+        consistentRead,
+        limit: input.limit,
+        resultItemLimit: input.resultItemLimit,
+        scanForward: input.scanIndexForward,
+    });
+    if (input.filterExpression) {
+        const filterTokens = tokenize(input.filterExpression, true);
+        const filterAttrs = new Set(classified.postReadFilter.attributes);
+        if (filterTokens) {
+            try {
+                const c = new TokenCursor(filterTokens);
+                const filterWhere = resolveAttributeNames(parseOr(c), input.expressionAttributeNames);
+                if (c.atEnd()) {
+                    collectAttributes(filterWhere, filterAttrs);
+                }
+            }
+            catch (_c) {
+            }
+        }
+        return Object.assign(Object.assign({}, classified), { postReadFilter: { present: true, attributes: [...filterAttrs] } });
+    }
+    return classified;
+}
+//# sourceMappingURL=dynamoPartiqlAccessPattern.js.map