All files / src/abap/5_syntax/statements insert_internal.ts

99.13% Statements 114/115
95% Branches 57/60
100% Functions 1/1
99.13% Lines 114/115

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 1161x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 102x 102x 102x 102x 100x 100x 102x 102x 102x 102x 102x 2x 2x 2x 102x 100x 88x 88x 100x 100x 100x 102x 94x 94x 33x 33x 94x 102x 102x 102x 102x 102x 102x 102x 1x 1x 1x 1x 99x 99x 102x 10x 10x 6x 10x 4x 4x 10x 99x 102x 93x 93x 1x 93x 1x 1x 92x   91x 1x 1x 91x 90x 90x 90x 1x 1x 1x 93x 93x 3x 3x 3x 3x 93x 96x 96x 102x 11x 11x 3x 11x 8x 8x 1x 1x 1x 1x 8x 11x 95x 102x 38x 33x 33x 5x 5x 95x 95x 1x  
import * as Expressions from "../../2_statements/expressions";
import {ExpressionNode, StatementNode} from "../../nodes";
import {InlineFS} from "../expressions/inline_fs";
import {Source} from "../expressions/source";
import {Target} from "../expressions/target";
import {FSTarget} from "../expressions/fstarget";
import {AbstractType} from "../../types/basic/_abstract_type";
import {AnyType, CharacterType, DataReference, Integer8Type, IntegerType, StringType, TableAccessType, TableType, UnknownType, VoidType} from "../../types/basic";
import {StatementSyntax} from "../_statement_syntax";
import {InlineData} from "../expressions/inline_data";
import {TypeUtils} from "../_type_utils";
import {SyntaxInput, syntaxIssue} from "../_syntax_input";
 
export class InsertInternal implements StatementSyntax {
  public runSyntax(node: StatementNode, input: SyntaxInput): void {
 
    let targetType: AbstractType | undefined;
    const t = node.findDirectExpression(Expressions.Target);
    if (t) {
      targetType = Target.runSyntax(t, input);
    }
    if (!(targetType instanceof TableType)
        && !(targetType instanceof VoidType)
        && !(targetType instanceof AnyType)
        && !(targetType instanceof UnknownType)
        && targetType !== undefined) {
      const message = "INSERT target must be a table";
      input.issues.push(syntaxIssue(input, node.getFirstToken(), message));
      return;
    } else if (targetType instanceof TableType
        && node.findDirectTokenByText("LINES") === undefined) {
      targetType = targetType.getRowType();
    }
 
    const initial = node.findDirectTokenByText("INITIAL") !== undefined;
    let source: ExpressionNode | undefined;
    if (initial === false) {
      source = node.findDirectExpression(Expressions.SimpleSource4);
      if (source === undefined) {
        source = node.findDirectExpression(Expressions.Source);
      }
    }
    const sourceType = source ? Source.runSyntax(source, input, targetType) : targetType;
 
    if (targetType === undefined
        && !(sourceType instanceof TableType)
        && !(sourceType instanceof VoidType)
        && !(sourceType instanceof AnyType)
        && !(sourceType instanceof UnknownType)) {
      const message = "INSERT target must be a table";
      input.issues.push(syntaxIssue(input, node.getFirstToken(), message));
      return;
    }
 
    const afterAssigning = node.findExpressionAfterToken("ASSIGNING");
    if (afterAssigning?.get() instanceof Expressions.FSTarget) {
      const inlinefs = afterAssigning?.findDirectExpression(Expressions.InlineFS);
      if (inlinefs) {
        InlineFS.runSyntax(inlinefs, input, sourceType);
      } else {
        FSTarget.runSyntax(afterAssigning, input, sourceType);
      }
    }
 
    if (initial === false) {
      let error = false;
      if (sourceType instanceof IntegerType && targetType instanceof Integer8Type) {
        error = true;
      } else if (targetType instanceof TableType && targetType.isWithHeader() && sourceType instanceof TableType) {
        // LINES OF into a table with header line, compare the row types
        error = new TypeUtils(input.scope).isAssignable(sourceType.getRowType(), targetType.getRowType()) === false;
      } else if (new TypeUtils(input.scope).isAssignable(sourceType, targetType) === false) {
        error = true;
      } else if (sourceType instanceof CharacterType && targetType instanceof StringType) {
        // yea, well, INSERT doesnt convert the values automatically, like everything else?
        error = true;
      } else if (sourceType instanceof CharacterType
          && targetType instanceof CharacterType
          && sourceType.getAbstractTypeData()?.derivedFromConstant === true
          && sourceType.getLength() !== targetType.getLength()) {
        // character literal of different length than the row type
        error = true;
      }
 
      if (error === true) {
        const message = "Types not compatible";
        input.issues.push(syntaxIssue(input, node.getFirstToken(), message));
        return;
      }
    }
 
    const afterInto = node.findExpressionAfterToken("INTO");
    if (afterInto?.get() instanceof Expressions.Target && sourceType) {
      const inline = afterInto.findDirectExpression(Expressions.InlineData);
      if (inline) {
        InlineData.runSyntax(afterInto, input, new DataReference(sourceType));
      } else {
        const type = Target.runSyntax(afterInto, input);
        if (type instanceof TableType && type.getAccessType() === TableAccessType.hashed) {
          const message = "Implicit or explicit index operation on hashed table is not possible";
          input.issues.push(syntaxIssue(input, node.getFirstToken(), message));
          return;
        }
      }
    }
 
    for (const s of node.findDirectExpressions(Expressions.Source)) {
      if (s === source) {
        continue;
      }
      Source.runSyntax(s, input, targetType);
    }
 
  }
}