pg-mvc-service 2.0.4 → 2.0.6

package/dist/models/SqlUtils/ValidateValueUtil.js

@@ -198,6 +198,52 @@ class ValidateValueUtil {
         }
         return true;
     }
+    static isErrorInteger(value) {
+        let numberValue;
+        if (typeof value === 'string') {
+            if (value.trim() === "" || isNaN(Number(value))) {
+                return true;
+            }
+            numberValue = Number(value);
+        }
+        else if (typeof value === 'number') {
+            numberValue = value;
+        }
+        else {
+            return true;
+        }
+        if (Number.isInteger(numberValue) === false) {
+            return true;
+        }
+        if (numberValue < -2147483648 || numberValue > 2147483647) {
+            return true;
+        }
+        return false;
+    }
+    static isErrorReal(value) {
+        let numberValue;
+        if (typeof value === 'string') {
+            if (value.trim() === "" || isNaN(Number(value))) {
+                return true;
+            }
+            numberValue = Number(value);
+        }
+        else if (typeof value === 'number') {
+            numberValue = value;
+        }
+        else {
+            return true;
+        }
+        // 特殊値チェック
+        if (isFinite(numberValue) === false) {
+            return true;
+        }
+        // 範囲チェック（real型の範囲）
+        if (numberValue < -3.4e38 || numberValue > 3.4e38) {
+            return true;
+        }
+        return false;
+    }
     static isErrorNumber(value) {
         if (typeof value === 'string') {
             if (value.trim() === "" || isNaN(Number(value))) {

package/dist/models/SqlUtils/WhereExpression.js

@@ -83,21 +83,21 @@ class WhereExpression {
         // Are the operators correct?
         const useableOperator = {
             integer: ["=", "!=", ">", ">=", "<", "<=", "in", "not in"],
-            'integer[]': [],
+            'integer[]': ["=", "any", "@>", "&&"],
             real: ["=", "!=", ">", ">=", "<", "<="],
-            'real[]': [],
+            'real[]': ["=", "any", "@>", "&&"],
             string: ["=", "!=", "like", "ilike", "h2f_like", "h2f_ilike", "in", "not in"],
-            'string[]': [],
+            'string[]': ["=", "any", "@>", "&&"],
             uuid: ["=", "!=", "in", "not in"],
-            'uuid[]': [],
+            'uuid[]': ["=", "any", "@>", "&&"],
             bool: ["=", "!=", "in", "not in"],
-            'bool[]': [],
+            'bool[]': ["=", "any", "@>", "&&"],
             date: ["=", "!=", ">", ">=", "<", "<="],
-            'date[]': [],
+            'date[]': ["=", "any", "@>", "&&"],
             time: ["=", "!=", ">", ">=", "<", "<="],
-            'time[]': [],
+            'time[]': ["=", "any", "@>", "&&"],
             timestamp: ["=", "!=", ">", ">=", "<", "<="],
-            'timestamp[]': [],
+            'timestamp[]': ["=", "any", "@>", "&&"],
             json: [],
             'json[]': [],
             jsonb: [],
@@ -124,8 +124,15 @@ class WhereExpression {
                 throw new Error(`When comparing with null, operators other than =, != cannot be used. (${operator})`);
             }
         }
-        if (leftColumn.type.endsWith("[]")) {
-            return this.createExpression(leftColumn, operator, right, varLength);
+        const isColumnRight = right !== null && typeof right === 'object' && 'model' in right && 'name' in right;
+        const isArrayColumnLeft = leftColumn.type.endsWith("[]");
+        if (isArrayColumnLeft) {
+            if (isColumnRight) {
+                return this.createExpressionArrayColumn(leftColumn, operator, right, varLength);
+            }
+            else {
+                return this.createExpressionArrayValue(leftColumn, operator, right, varLength);
+            }
         }
         else {
             return this.createExpression(leftColumn, operator, right, varLength);
@@ -156,8 +163,9 @@ class WhereExpression {
         // If the right side value is a column specification
         if (right !== null && typeof right === 'object' && 'model' in right && 'name' in right) {
             const rightColumn = right.model.getColumn(right.name);
+            // 型の不一致エラーメッセージを改善
             if (leftColumn.type !== rightColumn.type) {
-                throw new Error(`The types of [${leftColumn.tableName}].[${leftColumn.columnName}] and [${rightColumn.tableName}].[${rightColumn.columnName}] are different.`);
+                throw new Error(`Type mismatch: column [${leftColumn.tableName}].[${leftColumn.columnName}] (${leftColumn.type}) and [${rightColumn.tableName}].[${rightColumn.columnName}] (${rightColumn.type}) must be the same type.`);
             }
             // LIKE operators are different, so handle separately
             switch (operator) {
@@ -198,34 +206,167 @@ class WhereExpression {
         };
     }
     static createExpressionArrayValue(leftColumn, operator, right, varLength) {
-        // ValidateValueUtil.validateValue(leftColumn, right);
-        // LIKE operators are different, so handle separately
-        // switch (operator) {
-        //     case 'like':
-        //     case 'ilike':
-        //         return {
-        //             sql: `${leftColumn.expression} ${operator} $${varLength}`,
-        //             vars: [`%${right}%`]
-        //         }
-        //     case 'h2f_like': // half to full like
-        //     case 'h2f_ilike': // half to full ilike
-        //         return {
-        //             sql: `${this.makeSqlReplaceHalfToFull(leftColumn.expression)} ${operator.replace("h2f_", "")} ${this.makeSqlReplaceHalfToFull(`$${varLength}`)}`,
-        //             vars: [`%${right}%`]
-        //         }
-        // }
+        // バリデーションチェック
+        switch (operator) {
+            case 'any':
+                switch (leftColumn.type) {
+                    case 'integer[]':
+                        if (ValidateValueUtil_1.default.isErrorInteger(right)) {
+                            throw new Error(`Expected integer value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'real[]':
+                        if (ValidateValueUtil_1.default.isErrorReal(right)) {
+                            throw new Error(`Expected numeric value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'string[]':
+                        if (ValidateValueUtil_1.default.isErrorString(right)) {
+                            throw new Error(`Expected string value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'uuid[]':
+                        if (ValidateValueUtil_1.default.isErrorUUID(right)) {
+                            throw new Error(`Expected UUID value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'bool[]':
+                        if (ValidateValueUtil_1.default.isErrorBool(right)) {
+                            throw new Error(`Expected boolean value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'date[]':
+                        if (ValidateValueUtil_1.default.isErrorDate(right)) {
+                            throw new Error(`Expected date value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'time[]':
+                        if (ValidateValueUtil_1.default.isErrorTime(right)) {
+                            throw new Error(`Expected time value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'timestamp[]':
+                        if (ValidateValueUtil_1.default.isErrorTimestamp(right)) {
+                            throw new Error(`Expected timestamp value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                }
+                break;
+            case '=':
+            case '@>':
+            case '&&':
+                if (Array.isArray(right) === false) {
+                    throw new Error(`Expected array format for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                }
+                for (const value of right) {
+                    switch (leftColumn.type) {
+                        case 'integer[]':
+                            if (ValidateValueUtil_1.default.isErrorInteger(value)) {
+                                throw new Error(`Expected integer value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'real[]':
+                            if (ValidateValueUtil_1.default.isErrorReal(value)) {
+                                throw new Error(`Expected numeric value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'string[]':
+                            if (ValidateValueUtil_1.default.isErrorString(value)) {
+                                throw new Error(`Expected string value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'uuid[]':
+                            if (ValidateValueUtil_1.default.isErrorUUID(value)) {
+                                throw new Error(`Expected UUID value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'bool[]':
+                            if (ValidateValueUtil_1.default.isErrorBool(value)) {
+                                throw new Error(`Expected boolean value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'date[]':
+                            if (ValidateValueUtil_1.default.isErrorDate(value)) {
+                                throw new Error(`Expected date value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'time[]':
+                            if (ValidateValueUtil_1.default.isErrorTime(value)) {
+                                throw new Error(`Expected time value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'timestamp[]':
+                            if (ValidateValueUtil_1.default.isErrorTimestamp(value)) {
+                                throw new Error(`Expected timestamp value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                    }
+                }
+                break;
+            default:
+                throw new Error(`Unsupported operator '${operator}' for array column operations.`);
+        }
         switch (operator) {
             case '=':
-                // バリデーションチェックをする
+                // =で検索すると順番まで一致させないといけないので、順番不一致でも中身があってれば一致とするようにする
+                return {
+                    expression: `(${leftColumn.expression} @> $${varLength} AND $${varLength} @> $${leftColumn.expression})`,
+                    vars: [right]
+                };
+            case '@>':
+            case '&&':
                 return {
                     expression: `${leftColumn.expression} ${operator} $${varLength}`,
                     vars: [right]
                 };
+            case 'any':
+                return {
+                    expression: `$${varLength} = ANY(${leftColumn.expression})`,
+                    vars: [right]
+                };
+        }
+    }
+    static createExpressionArrayColumn(leftColumn, operator, right, varLength) {
+        const rightColumn = right.model.getColumn(right.name);
+        // バリデーションチェック
+        switch (operator) {
+            case 'any':
+                // any演算子の場合
+                if (leftColumn.type !== rightColumn.type.replace('[]', '')) {
+                    throw new Error(`Type mismatch: array column [${leftColumn.tableName}].[${leftColumn.columnName}] (${leftColumn.type}) and scalar column [${rightColumn.tableName}].[${rightColumn.columnName}] (${rightColumn.type}) are incompatible for ANY operation.`);
+                }
+                break;
+            case '=':
+            case '@>':
+            case '&&':
+                // 配列演算子の場合
+                if (leftColumn.type !== rightColumn.type) {
+                    throw new Error(`Type mismatch: array columns [${leftColumn.tableName}].[${leftColumn.columnName}] (${leftColumn.type}) and [${rightColumn.tableName}].[${rightColumn.columnName}] (${rightColumn.type}) must be the same type.`);
+                }
+                break;
+            default:
+                // サポートされていない演算子
+                throw new Error(`Operator '${operator}' is not supported for array column operations. Supported operators: =, @>, &&, ANY`);
+        }
+        switch (operator) {
+            case '=':
+                // =で検索すると順番まで一致させないといけないので、順番不一致でも中身があってれば一致とするようにする
+                return {
+                    expression: `(${leftColumn.expression} @> $${rightColumn.expression} AND ${rightColumn.expression} @> $${leftColumn.expression})`,
+                    vars: []
+                };
+            case '@>':
+            case '&&':
+                return {
+                    expression: `${leftColumn.expression} ${operator} $${rightColumn.expression}`,
+                    vars: []
+                };
+            case 'any':
+                return {
+                    expression: `$${rightColumn.expression} = ANY(${leftColumn.expression})`,
+                    vars: []
+                };
         }
-        return {
-            expression: `${leftColumn.expression} ${operator} $${varLength}`,
-            vars: [right]
-        };
     }
     /**
      * SQL statement to convert half-width characters to full-width

package/index.d.ts

@@ -20,7 +20,6 @@ import ValidateClient from './src/models/ValidateClient';
 import { TableModel } from "./src/models/TableModel";
 export { TableModel } from "./src/models/TableModel";
 
-import { TColumnAttribute, TColumnType, TColumnArrayType, TColumn, TColumnDetail, TOperator, TColumnInfo, TQuery, TSelectExpression, TAggregateFuncType, TCondition, TNestedCondition, TSortKeyword, TKeyFormat } from './src/models/Type';
 export { TColumnAttribute, TColumnType, TColumnArrayType, TColumn, TColumnDetail, TOperator, TColumnInfo, TQuery, TSelectExpression, TAggregateFuncType, TCondition, TNestedCondition, TSortKeyword, TKeyFormat } from './src/models/Type';
 
 declare module 'pg-mvc-service' {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-mvc-service",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "",
   "homepage": "https://github.com/n-daira/npm-pack_mvc-service#readme",
   "bugs": {

package/src/models/SqlUtils/ValidateValueUtil.ts

@@ -216,6 +216,58 @@ export default class ValidateValueUtil {
         return true;
     }
 
+    static isErrorInteger(value: any): boolean {
+        let numberValue: number;
+        if (typeof value === 'string') {
+            if (value.trim() === "" || isNaN(Number(value))) {
+                return true;
+            }
+
+            numberValue = Number(value);
+        } else if (typeof value === 'number') {
+            numberValue = value;
+        } else {
+            return true;
+        }
+
+        if (Number.isInteger(numberValue) === false) {
+            return true;
+        }
+
+        if (numberValue < -2147483648 || numberValue > 2147483647) {
+            return true;
+        }
+
+        return false;
+    }
+
+    static isErrorReal(value: any): boolean {
+        let numberValue: number;
+        if (typeof value === 'string') {
+            if (value.trim() === "" || isNaN(Number(value))) {
+                return true;
+            }
+
+            numberValue = Number(value);
+        } else if (typeof value === 'number') {
+            numberValue = value;
+        } else {
+            return true;
+        }
+
+        // 特殊値チェック
+        if (isFinite(numberValue) === false) {
+            return true;
+        }
+
+        // 範囲チェック（real型の範囲）
+        if (numberValue < -3.4e38 || numberValue > 3.4e38) {
+            return true;
+        }
+
+        return false;
+    }
+
     static isErrorNumber(value: any): boolean {
         if (typeof value === 'string') {
             if (value.trim() === "" || isNaN(Number(value))) {

package/src/models/SqlUtils/WhereExpression.ts

@@ -96,23 +96,23 @@ export default class WhereExpression {
         const leftColumn = left.model.getColumn(left.name);
 
         // Are the operators correct?
-        const useableOperator: { [key in TColumnType | TColumnArrayType]: string[] } = {
+        const useableOperator: { [key in TColumnType | TColumnArrayType]: TOperator[] } = {
             integer: ["=", "!=", ">", ">=", "<", "<=", "in", "not in"],
-            'integer[]': [],
+            'integer[]': ["=", "any", "@>", "&&"],
             real: ["=", "!=", ">", ">=", "<", "<="],
-            'real[]': [],
+            'real[]': ["=", "any", "@>", "&&"],
             string: ["=", "!=", "like", "ilike", "h2f_like", "h2f_ilike", "in", "not in"],
-            'string[]': [],
+            'string[]': ["=", "any", "@>", "&&"],
             uuid: ["=", "!=", "in", "not in"],
-            'uuid[]': [],
+            'uuid[]': ["=", "any", "@>", "&&"],
             bool: ["=", "!=", "in", "not in"],
-            'bool[]': [],
+            'bool[]': ["=", "any", "@>", "&&"],
             date: ["=", "!=", ">", ">=", "<", "<="],
-            'date[]': [],
+            'date[]': ["=", "any", "@>", "&&"],
             time: ["=", "!=", ">", ">=", "<", "<="],
-            'time[]': [],
+            'time[]': ["=", "any", "@>", "&&"],
             timestamp: ["=", "!=", ">", ">=", "<", "<="],
-            'timestamp[]': [],
+            'timestamp[]': ["=", "any", "@>", "&&"],
             json: [],
             'json[]': [],
             jsonb: [],
@@ -141,8 +141,14 @@ export default class WhereExpression {
             }
         }
 
-        if (leftColumn.type.endsWith("[]")) {
-            return this.createExpression(leftColumn, operator, right, varLength);
+        const isColumnRight = right !== null && typeof right === 'object' && 'model' in right && 'name' in right;
+        const isArrayColumnLeft = leftColumn.type.endsWith("[]");
+        if (isArrayColumnLeft) {
+            if (isColumnRight) {
+                return this.createExpressionArrayColumn(leftColumn, operator, right, varLength);
+            } else {
+                return this.createExpressionArrayValue(leftColumn, operator, right, varLength);
+            }
         } else {
             return this.createExpression(leftColumn, operator, right, varLength);
         }
@@ -176,8 +182,9 @@ export default class WhereExpression {
         if (right !== null && typeof right === 'object' && 'model' in right && 'name' in right) {
             const rightColumn = right.model.getColumn(right.name);
 
+            // 型の不一致エラーメッセージを改善
             if (leftColumn.type !== rightColumn.type) {
-                throw new Error(`The types of [${leftColumn.tableName}].[${leftColumn.columnName}] and [${rightColumn.tableName}].[${rightColumn.columnName}] are different.`);
+                throw new Error(`Type mismatch: column [${leftColumn.tableName}].[${leftColumn.columnName}] (${leftColumn.type}) and [${rightColumn.tableName}].[${rightColumn.columnName}] (${rightColumn.type}) must be the same type.`);
             }
 
             // LIKE operators are different, so handle separately
@@ -224,37 +231,172 @@ export default class WhereExpression {
 
     private static createExpressionArrayValue(leftColumn: TColumnDetail, operator: TOperator, right: any, varLength: number) : TQuery {
 
-        // ValidateValueUtil.validateValue(leftColumn, right);
-        // LIKE operators are different, so handle separately
-        // switch (operator) {
-        //     case 'like':
-        //     case 'ilike':
-        //         return {
-        //             sql: `${leftColumn.expression} ${operator} $${varLength}`,
-        //             vars: [`%${right}%`]
-        //         }
-        //     case 'h2f_like': // half to full like
-        //     case 'h2f_ilike': // half to full ilike
-        //         return {
-        //             sql: `${this.makeSqlReplaceHalfToFull(leftColumn.expression)} ${operator.replace("h2f_", "")} ${this.makeSqlReplaceHalfToFull(`$${varLength}`)}`,
-        //             vars: [`%${right}%`]
-        //         }
-        // }
+        // バリデーションチェック
+        switch (operator) {
+            case 'any':
+                switch (leftColumn.type) {
+                    case 'integer[]':
+                        if (ValidateValueUtil.isErrorInteger(right)) {
+                            throw new Error(`Expected integer value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'real[]':
+                        if (ValidateValueUtil.isErrorReal(right)) {
+                            throw new Error(`Expected numeric value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'string[]':
+                        if (ValidateValueUtil.isErrorString(right)) {
+                            throw new Error(`Expected string value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'uuid[]':
+                        if (ValidateValueUtil.isErrorUUID(right)) {
+                            throw new Error(`Expected UUID value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'bool[]':
+                        if (ValidateValueUtil.isErrorBool(right)) {
+                            throw new Error(`Expected boolean value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'date[]':
+                        if (ValidateValueUtil.isErrorDate(right)) {
+                            throw new Error(`Expected date value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'time[]':
+                        if (ValidateValueUtil.isErrorTime(right)) {
+                            throw new Error(`Expected time value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                    case 'timestamp[]':
+                        if (ValidateValueUtil.isErrorTimestamp(right)) {
+                            throw new Error(`Expected timestamp value for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                        }
+                        break;
+                }
+                break;
+            case '=':
+            case '@>':
+            case '&&':
+                if (Array.isArray(right) === false) {
+                    throw new Error(`Expected array format for array column (${leftColumn.type}), but received: ${JSON.stringify(right)}`);
+                }
+
+                for (const value of right) {
+                    switch (leftColumn.type) {
+                        case 'integer[]':
+                            if (ValidateValueUtil.isErrorInteger(value)) {
+                                throw new Error(`Expected integer value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'real[]':
+                            if (ValidateValueUtil.isErrorReal(value)) {
+                                throw new Error(`Expected numeric value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'string[]':
+                            if (ValidateValueUtil.isErrorString(value)) {
+                                throw new Error(`Expected string value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'uuid[]':
+                            if (ValidateValueUtil.isErrorUUID(value)) {
+                                throw new Error(`Expected UUID value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'bool[]':
+                            if (ValidateValueUtil.isErrorBool(value)) {
+                                throw new Error(`Expected boolean value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'date[]':
+                            if (ValidateValueUtil.isErrorDate(value)) {
+                                throw new Error(`Expected date value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'time[]':
+                            if (ValidateValueUtil.isErrorTime(value)) {
+                                throw new Error(`Expected time value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                        case 'timestamp[]':
+                            if (ValidateValueUtil.isErrorTimestamp(value)) {
+                                throw new Error(`Expected timestamp value in array element, but received: ${JSON.stringify(value)}`);
+                            }
+                            break;
+                    }
+                }
+                break;
+            default:
+                throw new Error(`Unsupported operator '${operator}' for array column operations.`);
+        }
 
         switch (operator) {
             case '=':
-                // バリデーションチェックをする
-                
+                // =で検索すると順番まで一致させないといけないので、順番不一致でも中身があってれば一致とするようにする
+                return {
+                    expression: `(${leftColumn.expression} @> $${varLength} AND $${varLength} @> $${leftColumn.expression})`,
+                    vars: [right]
+                }
+            case '@>':
+            case '&&':
                 return {
                     expression: `${leftColumn.expression} ${operator} $${varLength}`,
                     vars: [right]
                 }
+            case 'any':
+                return {
+                    expression: `$${varLength} = ANY(${leftColumn.expression})`,
+                    vars: [right]
+                }
         }
+    }
 
+    private static createExpressionArrayColumn(leftColumn: TColumnDetail, operator: TOperator, right: TColumnInfo, varLength: number) : TQuery {
 
-        return {
-            expression: `${leftColumn.expression} ${operator} $${varLength}`,
-            vars: [right]
+        const rightColumn = right.model.getColumn(right.name);
+
+        // バリデーションチェック
+        switch (operator) {
+            case 'any':
+                // any演算子の場合
+                if (leftColumn.type !== rightColumn.type.replace('[]', '')) {
+                    throw new Error(`Type mismatch: array column [${leftColumn.tableName}].[${leftColumn.columnName}] (${leftColumn.type}) and scalar column [${rightColumn.tableName}].[${rightColumn.columnName}] (${rightColumn.type}) are incompatible for ANY operation.`);
+                }
+                break;
+            case '=':
+            case '@>':
+            case '&&':
+                // 配列演算子の場合
+                if (leftColumn.type !== rightColumn.type) {
+                    throw new Error(`Type mismatch: array columns [${leftColumn.tableName}].[${leftColumn.columnName}] (${leftColumn.type}) and [${rightColumn.tableName}].[${rightColumn.columnName}] (${rightColumn.type}) must be the same type.`);
+                }
+                break;
+            default:
+                // サポートされていない演算子
+                throw new Error(`Operator '${operator}' is not supported for array column operations. Supported operators: =, @>, &&, ANY`);
+        }
+
+        switch (operator) {
+            case '=':
+                // =で検索すると順番まで一致させないといけないので、順番不一致でも中身があってれば一致とするようにする
+                return {
+                    expression: `(${leftColumn.expression} @> $${rightColumn.expression} AND ${rightColumn.expression} @> $${leftColumn.expression})`,
+                    vars: []
+                }
+            case '@>':
+            case '&&':
+                return {
+                    expression: `${leftColumn.expression} ${operator} $${rightColumn.expression}`,
+                    vars: []
+                }
+            case 'any':
+                return {
+                    expression: `$${rightColumn.expression} = ANY(${leftColumn.expression})`,
+                    vars: []
+                }
         }
     }
 

package/src/models/Type.ts

@@ -47,7 +47,7 @@ export type TColumnDetail = TColumn & {
     expression: string
 }
 
-export type TOperator = "=" | "!=" | ">" | ">=" | "<" | "<=" | "like" | "ilike" | "h2f_like" | "h2f_ilike" | "in" | "not in";
+export type TOperator = "=" | "!=" | ">" | ">=" | "<" | "<=" | "like" | "ilike" | "h2f_like" | "h2f_ilike" | "in" | "not in" | "any" | "@>" | "&&";
 export type TColumnInfo = { model: TableModel, name: string }
 export type TQuery = {expression: string, vars?: Array<any>};
 export type TSelectExpression = { expression: string, alias: string }