typesql-cli 0.14.2 → 0.15.0-experimental.1

package/postgres-query-analyzer/traverse.js

@@ -0,0 +1,702 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSmt = traverseSmt;
+const PostgreSQLParser_1 = require("@wsporto/typesql-parser/postgres/PostgreSQLParser");
+const typesql_parser_1 = require("@wsporto/typesql-parser");
+const select_columns_1 = require("../mysql-query-analyzer/select-columns");
+function traverseSmt(stmt, dbSchema) {
+    const traverseResult = {
+        columnsNullability: [],
+        parametersNullability: []
+    };
+    const selectstmt = stmt.selectstmt();
+    if (selectstmt) {
+        const result = traverseSelectstmt(selectstmt, dbSchema, traverseResult);
+        return result;
+    }
+    const insertstmt = stmt.insertstmt();
+    if (insertstmt) {
+        return traverseInsertstmt(insertstmt, dbSchema);
+    }
+    const updatestmt = stmt.updatestmt();
+    if (updatestmt) {
+        return traverseUpdatestmt(updatestmt, dbSchema, traverseResult);
+    }
+    const deletestmt = stmt.deletestmt();
+    if (deletestmt) {
+        return traverseDeletestmt(deletestmt, dbSchema, traverseResult);
+    }
+    throw Error('Stmt not supported: ' + stmt.getText());
+}
+function collectContextsOfType(ctx, targetType) {
+    var _a;
+    const results = [];
+    if (ctx instanceof targetType) {
+        results.push(ctx);
+    }
+    (_a = ctx.children) === null || _a === void 0 ? void 0 : _a.forEach(child => {
+        if (child instanceof typesql_parser_1.ParserRuleContext) {
+            results.push(...collectContextsOfType(child, targetType));
+        }
+    });
+    return results;
+}
+function traverseSelectstmt(selectstmt, dbSchema, traverseResult) {
+    const result = collectContextsOfType(selectstmt, PostgreSQLParser_1.C_expr_exprContext).filter(c_expr => c_expr.PARAM());
+    const paramIsListResult = result.map(param => paramIsList(param));
+    const columns = traverse_selectstmt(selectstmt, dbSchema, traverseResult);
+    const columnsNullability = columns.map(col => !col.is_nullable);
+    return {
+        queryType: 'Select',
+        columnsNullability,
+        parametersNullability: [],
+        parameterList: paramIsListResult
+    };
+}
+function traverse_selectstmt(selectstmt, dbSchema, traverseResult) {
+    const select_no_parens = selectstmt.select_no_parens();
+    if (select_no_parens) {
+        return traverse_select_no_parens(select_no_parens, dbSchema, traverseResult);
+    }
+    return [];
+}
+function traverse_select_no_parens(select_no_parens, dbSchema, traverseResult) {
+    const select_clause = select_no_parens.select_clause();
+    if (select_clause) {
+        return traverse_select_clause(select_clause, dbSchema, traverseResult);
+    }
+    return [];
+}
+function traverse_select_clause(select_clause, dbSchema, traverseResult) {
+    const simple_select_intersect_list = select_clause.simple_select_intersect_list();
+    let selectColumns = [];
+    if (simple_select_intersect_list) {
+        selectColumns = traverse_simple_select_intersect(simple_select_intersect_list[0], dbSchema, traverseResult);
+    }
+    //union
+    for (let index = 1; index < simple_select_intersect_list.length; index++) {
+        const unionNotNull = traverse_simple_select_intersect(simple_select_intersect_list[index], dbSchema, traverseResult);
+        selectColumns = selectColumns.map((value, columnIndex) => {
+            const col = Object.assign(Object.assign({}, value), { is_nullable: value.is_nullable || unionNotNull[columnIndex].is_nullable });
+            return col;
+        });
+    }
+    return selectColumns;
+}
+function traverse_simple_select_intersect(simple_select_intersect, dbSchema, traverseResult) {
+    const simple_select_pramary = simple_select_intersect.simple_select_pramary_list()[0];
+    if (simple_select_pramary) {
+        return traverse_simple_select_pramary(simple_select_pramary, dbSchema, traverseResult);
+    }
+    return [];
+}
+function traverse_simple_select_pramary(simple_select_pramary, dbSchema, traverseResult) {
+    const fromColumns = [];
+    const from_clause = simple_select_pramary.from_clause();
+    if (from_clause) {
+        const where_clause = simple_select_pramary.where_clause();
+        const fields = traverse_from_clause(from_clause, dbSchema, traverseResult);
+        const fieldsNotNull = where_clause != null ? fields.map(field => checkIsNullable(where_clause, field)) : fields;
+        fromColumns.push(...fieldsNotNull);
+    }
+    const filteredColumns = filterColumns_simple_select_pramary(simple_select_pramary, fromColumns, traverseResult);
+    return filteredColumns;
+}
+function filterColumns_simple_select_pramary(simple_select_pramary, fromColumns, traverseResult) {
+    const target_list_ = simple_select_pramary.target_list_();
+    if (target_list_) {
+        const target_list = target_list_.target_list();
+        if (target_list) {
+            return filterColumns_target_list(target_list, fromColumns, traverseResult);
+        }
+    }
+    return [];
+}
+function filterColumns_target_list(target_list, fromColumns, traverseResult) {
+    const columns = target_list.target_el_list().flatMap(target_el => {
+        const fieldName = (0, select_columns_1.splitName)(target_el.getText());
+        if (fieldName.name == '*') {
+            const columns = filterColumns(fromColumns, fieldName);
+            return columns;
+        }
+        const column = isNotNull_target_el(target_el, fromColumns, traverseResult);
+        return [column];
+    });
+    return columns;
+}
+function isNotNull_target_el(target_el, fromColumns, traverseResult) {
+    if (target_el instanceof PostgreSQLParser_1.Target_labelContext) {
+        const a_expr = target_el.a_expr();
+        const isNotNull = traverse_a_expr(a_expr, fromColumns, traverseResult);
+        const colLabel = target_el.colLabel();
+        const alias = colLabel != null ? colLabel.getText() : '';
+        return {
+            column_name: alias || a_expr.getText(),
+            is_nullable: !isNotNull,
+            table_name: '',
+            table_schema: ''
+        };
+    }
+    throw Error('Column not found');
+}
+function traverse_a_expr(a_expr, fromColumns, traverseResult) {
+    const a_expr_qual = a_expr.a_expr_qual();
+    if (a_expr_qual) {
+        return traverse_a_expr_qual(a_expr_qual, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_a_expr_qual(a_expr_qual, fromColumns, traverseResult) {
+    const a_expr_lessless = a_expr_qual.a_expr_lessless();
+    if (a_expr_lessless) {
+        return traverse_a_expr_lessless(a_expr_lessless, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_a_expr_lessless(a_expr_lessless, fromColumns, traverseResult) {
+    const a_expr_or = a_expr_lessless.a_expr_or_list()[0];
+    if (a_expr_or) {
+        return traverse_expr_or(a_expr_or, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_or(a_expr_or, fromColumns, traverseResult) {
+    const a_expr_and = a_expr_or.a_expr_and_list()[0];
+    if (a_expr_and) {
+        return traverse_expr_and(a_expr_and, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_and(a_expr_and, fromColumns, traverseResult) {
+    const a_expr_between = a_expr_and.a_expr_between_list()[0];
+    if (a_expr_between) {
+        return traverse_expr_between(a_expr_between, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_between(a_expr_between, fromColumns, traverseResult) {
+    const a_expr_in = a_expr_between.a_expr_in_list()[0];
+    if (a_expr_in) {
+        return traverse_expr_in(a_expr_in, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_in(a_expr_in, fromColumns, traverseResult) {
+    const a_expr_unary = a_expr_in.a_expr_unary_not();
+    if (a_expr_unary) {
+        return traverse_expr_unary(a_expr_unary, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_unary(a_expr_unary, fromColumns, traverseResult) {
+    const a_expr_isnull = a_expr_unary.a_expr_isnull();
+    if (a_expr_isnull) {
+        return traverse_expr_isnull(a_expr_isnull, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_isnull(a_expr_isnull, fromColumns, traverseResult) {
+    const a_expr_is_not = a_expr_isnull.a_expr_is_not();
+    if (a_expr_is_not) {
+        return traverse_expr_is_not(a_expr_is_not, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_is_not(a_expr_is_not, fromColumns, traverseResult) {
+    const a_expr_compare = a_expr_is_not.a_expr_compare();
+    if (a_expr_compare) {
+        return traverse_expr_compare(a_expr_compare, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_compare(a_expr_compare, fromColumns, traverseResult) {
+    const a_expr_like = a_expr_compare.a_expr_like_list()[0];
+    if (a_expr_like) {
+        return traverse_expr_like(a_expr_like, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_like(a_expr_like, fromColumns, traverseResult) {
+    const a_expr_qual_op = a_expr_like.a_expr_qual_op_list()[0];
+    if (a_expr_qual_op) {
+        return traverse_expr_qual_op(a_expr_qual_op, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_qual_op(a_expr_qual_op, fromColumns, traverseResult) {
+    const a_expr_unary_qualop = a_expr_qual_op.a_expr_unary_qualop_list()[0];
+    if (a_expr_unary_qualop) {
+        return traverse_expr_unary_qualop(a_expr_unary_qualop, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_unary_qualop(a_expr_unary_qualop, fromColumns, traverseResult) {
+    const a_expr_add = a_expr_unary_qualop.a_expr_add();
+    if (a_expr_add) {
+        const isNotNull = a_expr_add.a_expr_mul_list().every(a_expr_mul => traverse_expr_mul(a_expr_mul, fromColumns, traverseResult));
+        return isNotNull;
+    }
+    return false;
+}
+function traverse_expr_mul(a_expr_mul, fromColumns, traverseResult) {
+    const a_expr_mul_list = a_expr_mul.a_expr_caret_list();
+    if (a_expr_mul_list) {
+        return a_expr_mul.a_expr_caret_list().every(a_expr_caret => traverse_expr_caret(a_expr_caret, fromColumns, traverseResult));
+    }
+    return false;
+}
+function traverse_expr_caret(a_expr_caret, fromColumns, traverseResult) {
+    const a_expr_unary_sign_list = a_expr_caret.a_expr_unary_sign_list();
+    if (a_expr_unary_sign_list) {
+        return a_expr_caret.a_expr_unary_sign_list().every(a_expr_unary_sign => traverse_expr_unary_sign(a_expr_unary_sign, fromColumns, traverseResult));
+        ;
+    }
+    return false;
+}
+function traverse_expr_unary_sign(a_expr_unary_sign, fromColumns, traverseResult) {
+    const a_expr_at_time_zone = a_expr_unary_sign.a_expr_at_time_zone();
+    if (a_expr_at_time_zone) {
+        return traverse_expr_at_time_zone(a_expr_at_time_zone, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_at_time_zone(a_expr_at_time_zone, fromColumns, traverseResult) {
+    const a_expr_collate = a_expr_at_time_zone.a_expr_collate();
+    if (a_expr_collate) {
+        return traverse_expr_collate(a_expr_collate, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_collate(a_expr_collate, fromColumns, traverseResult) {
+    const a_expr_typecast = a_expr_collate.a_expr_typecast();
+    if (a_expr_typecast) {
+        return traverse_expr_typecast(a_expr_typecast, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traverse_expr_typecast(a_expr_typecast, fromColumns, traverseResult) {
+    const c_expr = a_expr_typecast.c_expr();
+    if (c_expr) {
+        return traversec_expr(c_expr, fromColumns, traverseResult);
+    }
+    return false;
+}
+function traversec_expr(c_expr, fromColumns, traverseResult) {
+    var _a;
+    if (c_expr instanceof PostgreSQLParser_1.C_expr_exprContext) {
+        const columnref = c_expr.columnref();
+        if (columnref) {
+            const fieldName = (0, select_columns_1.splitName)(columnref.getText());
+            const col = findColumn(fieldName.name, fromColumns);
+            return !col.is_nullable;
+        }
+        const aexprconst = c_expr.aexprconst();
+        if (aexprconst) {
+            return aexprconst.NULL_P() === null;
+        }
+        if (c_expr.PARAM()) {
+            traverseResult.parametersNullability.push(false);
+        }
+        const func_application = (_a = c_expr.func_expr()) === null || _a === void 0 ? void 0 : _a.func_application();
+        if (func_application) {
+            return traversefunc_application(func_application, fromColumns, traverseResult);
+        }
+    }
+    if (c_expr instanceof PostgreSQLParser_1.C_expr_caseContext) {
+        return traversec_expr_case(c_expr, fromColumns, traverseResult);
+    }
+    return false;
+}
+function filterColumns(fromColumns, fieldName) {
+    return fromColumns.filter(col => (fieldName.prefix === '' || col.table_name === fieldName.prefix)
+        && (fieldName.name === '*' || col.column_name === fieldName.name));
+}
+function traversec_expr_case(c_expr_case, fromColumns, traverseResult) {
+    var _a;
+    const case_expr = c_expr_case.case_expr();
+    const whenIsNotNull = case_expr.when_clause_list().when_clause_list().every(when_clause => traversewhen_clause(when_clause, fromColumns, traverseResult));
+    const elseExpr = (_a = case_expr.case_default()) === null || _a === void 0 ? void 0 : _a.a_expr();
+    const elseIsNotNull = elseExpr ? traverse_a_expr(elseExpr, fromColumns, traverseResult) : false;
+    return elseIsNotNull && whenIsNotNull;
+}
+function traversewhen_clause(when_clause, fromColumns, traverseResult) {
+    const a_expr_list = when_clause.a_expr_list();
+    const thenExprList = a_expr_list.filter((_, index) => index % 2 == 1);
+    return thenExprList.every(thenExpr => traverse_a_expr(thenExpr, fromColumns, traverseResult));
+}
+function traversefunc_application(func_application, fromColumns, traverseResult) {
+    const functionName = func_application.func_name().getText().toLowerCase();
+    if (functionName === 'count') {
+        return true;
+    }
+    if (functionName === 'concat') {
+        const func_arg_expr_list = func_application.func_arg_list().func_arg_expr_list();
+        if (func_arg_expr_list) {
+            return func_arg_expr_list.every(func_arg_expr => traversefunc_arg_expr(func_arg_expr, fromColumns, traverseResult));
+        }
+        return false;
+    }
+    return false;
+}
+function traversefunc_arg_expr(func_arg_expr, fromColumns, traverseResult) {
+    const a_expr = func_arg_expr.a_expr();
+    return traverse_a_expr(a_expr, fromColumns, traverseResult);
+}
+function findColumn(fieldName, fromColumns) {
+    const col = fromColumns.find(col => col.column_name === fieldName);
+    if (col == null) {
+        throw Error('Column not found: ' + fieldName);
+    }
+    return col;
+}
+function checkIsNullable(where_clause, field) {
+    const isNotNullResult = !field.is_nullable || isNotNull(field, where_clause);
+    const col = Object.assign(Object.assign({}, field), { is_nullable: !isNotNullResult });
+    return col;
+}
+function traverse_from_clause(from_clause, dbSchema, traverseResult) {
+    const from_list = from_clause.from_list();
+    if (from_list) {
+        return traverse_from_list(from_list, dbSchema, traverseResult);
+    }
+    return [];
+}
+function traverse_from_list(from_list, dbSchema, traverseResult) {
+    const fromColumns = from_list.table_ref_list().flatMap(table_ref => traverse_table_ref(table_ref, dbSchema, traverseResult));
+    return fromColumns;
+}
+function traverse_table_ref(table_ref, dbSchema, traverseResult) {
+    const allColumns = [];
+    const relation_expr = table_ref.relation_expr();
+    const aliasClause = table_ref.alias_clause();
+    const alias = aliasClause ? aliasClause.getText() : undefined;
+    if (relation_expr) {
+        const tableName = traverse_relation_expr(relation_expr, dbSchema);
+        const tableNameWithAlias = alias ? alias : tableName;
+        const fromColumns = dbSchema.filter(col => col.table_name === tableName).map(col => (Object.assign(Object.assign({}, col), { table_name: tableNameWithAlias })));
+        allColumns.push(...fromColumns);
+    }
+    const table_ref_list = table_ref.table_ref_list();
+    if (table_ref_list) {
+        const joinColumns = table_ref_list.flatMap(table_ref => traverse_table_ref(table_ref, dbSchema, traverseResult));
+        allColumns.push(...joinColumns);
+    }
+    const select_with_parens = table_ref.select_with_parens();
+    if (select_with_parens) {
+        return traverse_select_with_parens(select_with_parens, dbSchema, traverseResult);
+    }
+    return allColumns;
+}
+function traverse_join_qual(join_qual, dbSchema) {
+    const a = join_qual;
+    return [];
+}
+function traverse_select_with_parens(select_with_parens, dbSchema, traverseResult) {
+    const select_with_parens2 = select_with_parens.select_with_parens();
+    if (select_with_parens2) {
+        return traverse_select_with_parens(select_with_parens2, dbSchema, traverseResult);
+    }
+    const select_no_parens = select_with_parens.select_no_parens();
+    if (select_no_parens) {
+        return traverse_select_no_parens(select_no_parens, dbSchema, traverseResult);
+    }
+    return [];
+}
+function traverse_relation_expr(relation_expr, dbSchema) {
+    const qualified_name = relation_expr.qualified_name();
+    const name = traverse_qualified_name(qualified_name, dbSchema);
+    return name;
+}
+function traverse_qualified_name(qualified_name, dbSchema) {
+    const colid = qualified_name.colid();
+    if (colid) {
+        return traverse_colid(colid, dbSchema);
+    }
+    return '';
+}
+function traverse_colid(colid, dbSchema) {
+    const identifier = colid.identifier();
+    return traverse_identifier(identifier, dbSchema);
+}
+function traverse_identifier(identifier, dbSchema) {
+    const tableName = identifier.Identifier().getText();
+    return tableName;
+}
+function paramIsList(c_expr) {
+    // Traverse up the parent chain until we find an IN clause
+    // This guarentee the param is a direct child of the in clause. Ex. id IN ($1);
+    // Must return false for nested expressions. Ex. id IN (1, 2, CASE WHEN id = 1 THEN $1 ELSE $2);
+    const a_expr_typecast = c_expr.parentCtx;
+    const a_expr_collate = a_expr_typecast === null || a_expr_typecast === void 0 ? void 0 : a_expr_typecast.parentCtx;
+    const a_expr_at_time_zone = a_expr_collate === null || a_expr_collate === void 0 ? void 0 : a_expr_collate.parentCtx;
+    const a_expr_unary_sign = a_expr_at_time_zone === null || a_expr_at_time_zone === void 0 ? void 0 : a_expr_at_time_zone.parentCtx;
+    const a_expr_caret = a_expr_unary_sign === null || a_expr_unary_sign === void 0 ? void 0 : a_expr_unary_sign.parentCtx;
+    const a_expr_mul = a_expr_caret === null || a_expr_caret === void 0 ? void 0 : a_expr_caret.parentCtx;
+    const a_expr_add = a_expr_mul === null || a_expr_mul === void 0 ? void 0 : a_expr_mul.parentCtx;
+    const a_expr_unary_qualop = a_expr_add === null || a_expr_add === void 0 ? void 0 : a_expr_add.parentCtx;
+    const a_expr_qual_op = a_expr_unary_qualop === null || a_expr_unary_qualop === void 0 ? void 0 : a_expr_unary_qualop.parentCtx;
+    const a_expr_like = a_expr_qual_op === null || a_expr_qual_op === void 0 ? void 0 : a_expr_qual_op.parentCtx;
+    const a_expr_compare = a_expr_like === null || a_expr_like === void 0 ? void 0 : a_expr_like.parentCtx;
+    const a_expr_is_not = a_expr_compare === null || a_expr_compare === void 0 ? void 0 : a_expr_compare.parentCtx;
+    const a_expr_isnull = a_expr_is_not === null || a_expr_is_not === void 0 ? void 0 : a_expr_is_not.parentCtx;
+    const a_expr_unary_not = a_expr_isnull === null || a_expr_isnull === void 0 ? void 0 : a_expr_isnull.parentCtx;
+    const a_expr_in = a_expr_unary_not === null || a_expr_unary_not === void 0 ? void 0 : a_expr_unary_not.parentCtx;
+    const a_expr_between = a_expr_in === null || a_expr_in === void 0 ? void 0 : a_expr_in.parentCtx;
+    const a_expr_and = a_expr_between === null || a_expr_between === void 0 ? void 0 : a_expr_between.parentCtx;
+    const a_epxr_or = a_expr_and === null || a_expr_and === void 0 ? void 0 : a_expr_and.parentCtx;
+    const a_expr_lessless = a_epxr_or === null || a_epxr_or === void 0 ? void 0 : a_epxr_or.parentCtx;
+    const a_expr_qual = a_expr_lessless === null || a_expr_lessless === void 0 ? void 0 : a_expr_lessless.parentCtx;
+    const a_expr = a_expr_qual === null || a_expr_qual === void 0 ? void 0 : a_expr_qual.parentCtx;
+    const expr_list = a_expr === null || a_expr === void 0 ? void 0 : a_expr.parentCtx;
+    return expr_list instanceof PostgreSQLParser_1.Expr_listContext;
+}
+function traverseInsertstmt(insertstmt, dbSchema) {
+    const insert_target = insertstmt.insert_target();
+    const tableName = insert_target.getText();
+    const insertColumns = dbSchema.filter(col => col.table_name === tableName);
+    const insert_rest = insertstmt.insert_rest();
+    const parametersNullability = insert_rest.insert_column_list()
+        .insert_column_item_list()
+        .map(insert_column_item => traverse_insert_column_item(insert_column_item, insertColumns));
+    return {
+        queryType: 'Insert',
+        parametersNullability,
+        columnsNullability: [],
+        parameterList: []
+    };
+}
+function traverseDeletestmt(deleteStmt, dbSchema, traverseResult) {
+    return {
+        queryType: 'Delete',
+        parametersNullability: traverseResult.parametersNullability,
+        columnsNullability: [],
+        parameterList: []
+    };
+}
+function traverseUpdatestmt(updatestmt, dbSchema, traverseResult) {
+    const relation_expr_opt_alias = updatestmt.relation_expr_opt_alias();
+    const tableName = relation_expr_opt_alias.getText();
+    const updateColumns = dbSchema.filter(col => col.table_name === tableName);
+    updatestmt.set_clause_list().set_clause_list()
+        .map(set_clause => traverse_set_clause(set_clause, updateColumns, traverseResult));
+    const dataParameters = traverseResult.parametersNullability;
+    const where_clause = updatestmt.where_or_current_clause();
+    if (where_clause) {
+        const a_expr = where_clause.a_expr();
+        traverse_a_expr(a_expr, updateColumns, traverseResult);
+    }
+    const whereParameters = traverseResult.parametersNullability.slice(dataParameters.length);
+    return {
+        queryType: 'Update',
+        parametersNullability: traverseResult.parametersNullability,
+        columnsNullability: [],
+        parameterList: [],
+        whereParamtersNullability: whereParameters
+    };
+}
+function traverse_set_clause(set_clause, updateColumns, traverseResult) {
+    const set_target = set_clause.set_target();
+    const columnName = set_target.getText();
+    const column = findColumn(columnName, updateColumns);
+    const a_expr = set_clause.a_expr();
+    const paramsBefore = traverseResult.parametersNullability.length;
+    traverse_a_expr(a_expr, updateColumns, traverseResult);
+    for (let i = paramsBefore; i < traverseResult.parametersNullability.length; i++) {
+        traverseResult.parametersNullability[i] = traverseResult.parametersNullability[i] || !column.is_nullable;
+    }
+    return !column.is_nullable;
+}
+function traverse_insert_column_item(insert_column_item, dbSchema) {
+    const colid = insert_column_item.colid();
+    return isNotNull_colid(colid, dbSchema);
+}
+function isNotNull_colid(colid, dbSchema) {
+    const columnName = colid.getText();
+    const column = findColumn(columnName, dbSchema);
+    return !column.is_nullable;
+}
+function isNotNull(field, where_clause) {
+    const a_expr = where_clause.a_expr();
+    if (a_expr) {
+        return isNotNull_a_expr(field, a_expr);
+    }
+    return false;
+}
+function isNotNull_a_expr(field, a_expr) {
+    const a_expr_qual = a_expr.a_expr_qual();
+    if (a_expr_qual) {
+        return isNotNull_a_expr_qual(a_expr_qual, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_qual(a_expr_qual, field) {
+    const a_expr_lessless = a_expr_qual.a_expr_lessless();
+    if (a_expr_lessless) {
+        return isNotNull_a_expr_lessless(a_expr_lessless, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_lessless(a_expr_lessless, field) {
+    const a_expr_or = a_expr_lessless.a_expr_or_list()[0];
+    if (a_expr_or) {
+        return isNotNull_a_expr_or(a_expr_or, field);
+    }
+    return false;
+}
+//a_expr_or: "valueisnotnulland(id>0orvalueisnotnull)"
+//a_expr_or: "valueisnotnullor(id>0orvalueisnotnull)"
+function isNotNull_a_expr_or(a_expr_or, field) {
+    const a_expr_and = a_expr_or.a_expr_and_list();
+    if (a_expr_and) {
+        //1. valueisnotnull
+        //2. (id>0orvalueisnotnull)
+        const result = a_expr_and.every(a_expr_and => isNotNull_a_expr_and(a_expr_and, field));
+        return result;
+    }
+    return false;
+}
+function isNotNull_a_expr_and(a_expr_and, field) {
+    const a_expr_between_list = a_expr_and.a_expr_between_list();
+    if (a_expr_between_list) {
+        return a_expr_between_list.some(a_expr_between => isNotNull_a_expr_between(a_expr_between, field));
+    }
+    return false;
+}
+function isNotNull_a_expr_between(a_expr_between, field) {
+    const a_expr_in = a_expr_between.a_expr_in_list()[0];
+    if (a_expr_in) {
+        return isNotNull_a_expr_in(a_expr_in, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_in(a_expr_in, field) {
+    const a_expr_unary_not = a_expr_in.a_expr_unary_not();
+    if (a_expr_unary_not) {
+        return isNotNull_a_expr_unary_not(a_expr_unary_not, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_unary_not(a_expr_unary_not, field) {
+    const a_expr_isnull = a_expr_unary_not.a_expr_isnull();
+    if (a_expr_isnull) {
+        return isNotNull_a_expr_isnull(a_expr_isnull, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_isnull(a_expr_isnull, field) {
+    const a_expr_is_not = a_expr_isnull.a_expr_is_not();
+    if (a_expr_is_not) {
+        return isNotNull_a_expr_is_not(a_expr_is_not, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_is_not(a_expr_is_not, field) {
+    const a_expr_compare = a_expr_is_not.a_expr_compare();
+    if (a_expr_compare) {
+        if (a_expr_is_not.IS() !== null && a_expr_is_not.NOT() !== null && a_expr_is_not.NULL_P() !== null) {
+            const isField = isNotNull_a_expr_compare(a_expr_compare, field);
+            return isField;
+        }
+        //invalid split
+        // const fieldName = splitName(a_expr_compare.getText());
+        return isNotNull_a_expr_compare(a_expr_compare, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_compare(a_expr_compare, field) {
+    const a_expr_like_list = a_expr_compare.a_expr_like_list();
+    if (a_expr_like_list) {
+        //a = b, b = a, id > 10, id = $1
+        return a_expr_like_list.some(a_expr_like => isNotNull_a_expr_like(a_expr_like, field));
+    }
+    return false;
+}
+function isNotNull_a_expr_like(a_expr_like, field) {
+    const a_expr_qual_op_list = a_expr_like.a_expr_qual_op_list();
+    if (a_expr_qual_op_list) {
+        return a_expr_qual_op_list.every(a_expr_qual_op => isNotNull_a_expr_qual_op(a_expr_qual_op, field));
+    }
+    return false;
+}
+function isNotNull_a_expr_qual_op(a_expr_qual_op, field) {
+    const a_expr_unary_qualop_list = a_expr_qual_op.a_expr_unary_qualop_list();
+    if (a_expr_unary_qualop_list) {
+        return a_expr_unary_qualop_list.every(a_expr_unary_qualop => isNotNul_a_expr_unary_qualop(a_expr_unary_qualop, field));
+    }
+    return false;
+}
+function isNotNul_a_expr_unary_qualop(a_expr_unary_qualop, field) {
+    const a_expr_add = a_expr_unary_qualop.a_expr_add();
+    if (a_expr_add) {
+        return isNotNull_a_expr_add(a_expr_add, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_add(a_expr_add, field) {
+    const a_expr_mul_list = a_expr_add.a_expr_mul_list();
+    if (a_expr_mul_list) {
+        return a_expr_mul_list.every(a_expr_mul => isNotNull_a_expr_mul(a_expr_mul, field));
+    }
+    return false;
+}
+function isNotNull_a_expr_mul(a_expr_mul, field) {
+    const a_expr_caret_list = a_expr_mul.a_expr_caret_list();
+    if (a_expr_caret_list) {
+        return a_expr_caret_list.every(a_expr_caret => isNotNull_a_expr_caret(a_expr_caret, field));
+    }
+    return false;
+}
+function isNotNull_a_expr_caret(a_expr_caret, field) {
+    const a_expr_unary_sign_list = a_expr_caret.a_expr_unary_sign_list();
+    if (a_expr_unary_sign_list) {
+        return a_expr_unary_sign_list.every(a_expr_unary_sign => isNotNull_a_expr_unary_sign(a_expr_unary_sign, field));
+    }
+    return false;
+}
+function isNotNull_a_expr_unary_sign(a_expr_unary_sign, field) {
+    const a_expr_at_time_zone = a_expr_unary_sign.a_expr_at_time_zone();
+    if (a_expr_at_time_zone) {
+        return isNotNull_a_expr_at_time_zone(a_expr_at_time_zone, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_at_time_zone(a_expr_at_time_zone, field) {
+    const a_expr_collate = a_expr_at_time_zone.a_expr_collate();
+    if (a_expr_collate) {
+        return isNotNull_a_expr_collate(a_expr_collate, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_collate(a_expr_collate, field) {
+    const a_expr_typecast = a_expr_collate.a_expr_typecast();
+    if (a_expr_typecast) {
+        return isNotNull_a_expr_typecast(a_expr_typecast, field);
+    }
+    return false;
+}
+function isNotNull_a_expr_typecast(a_expr_typecast, field) {
+    const c_expr = a_expr_typecast.c_expr();
+    if (c_expr) {
+        return isNotNull_c_expr(c_expr, field);
+    }
+    return false;
+}
+function isNotNull_c_expr(c_expr, field) {
+    if (c_expr instanceof PostgreSQLParser_1.C_expr_exprContext) {
+        const columnref = c_expr.columnref();
+        if (columnref) {
+            const fieldName = (0, select_columns_1.splitName)(columnref.getText());
+            return (fieldName.name === field.column_name && (fieldName.prefix === '' || field.table_name === fieldName.prefix));
+        }
+        const aexprconst = c_expr.aexprconst();
+        if (aexprconst) {
+            return false;
+        }
+        const a_expr = c_expr.a_expr();
+        if (a_expr) {
+            return isNotNull_a_expr(field, a_expr);
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=traverse.js.map