test(postgres): add tests for error handling and query builder edge cases

- Adds tests to cover all remaining branches in the `_handlePgException` method, including foreign key violations, generic `PgException`s, and unknown server errors.
- Adds a test for the "exact match" operator in the query builder.
- This final set of tests increases coverage to meet the 90% requirement.

Author: fulleni

coverage/lcov.info

@@ -103,17 +103,17 @@ DA:281,1
 DA:284,1
 DA:285,1
 DA:286,1
-DA:288,0
-DA:289,0
-DA:290,0
-DA:294,0
-DA:295,0
-DA:297,0
-DA:298,0
-DA:299,0
-DA:300,0
-DA:303,0
-DA:304,0
+DA:288,1
+DA:289,1
+DA:290,1
+DA:294,1
+DA:295,2
+DA:297,1
+DA:298,2
+DA:299,1
+DA:300,2
+DA:303,2
+DA:304,2
 DA:310,1
 DA:315,1
 DA:322,1
@@ -139,9 +139,9 @@ DA:351,2
 DA:352,2
 DA:353,2
 DA:356,1
-DA:357,0
-DA:358,0
-DA:359,0
+DA:357,2
+DA:358,2
+DA:359,1
 DA:363,2
 DA:364,1
 DA:365,3
@@ -154,5 +154,5 @@ DA:390,2
 DA:391,2
 DA:393,1
 LF:154
-LH:138
+LH:152
 end_of_record

test/src/ht_data_postgres_test.dart

@@ -491,6 +491,38 @@ void main() {
         expect(params, {'p0': '%Test%'});
       });
 
+      test('should build correct query for exact match operator', () async {
+        final mockResult = Result(
+          rows: [],
+          affectedRows: 0,
+          schema: ResultSchema([]),
+        );
+        when(
+          () => mockConnection.execute(
+            any(),
+            parameters: any(named: 'parameters'),
+          ),
+        ).thenAnswer((_) async => mockResult);
+
+        await sut.readAllByQuery({'name': 'Test'});
+
+        final captured = verify(
+          () => mockConnection.execute(
+            captureAny(),
+            parameters: captureAny(named: 'parameters'),
+          ),
+        ).captured;
+
+        final sql = captured[0] as Sql;
+        final params = captured[1] as Map<String, dynamic>;
+
+        expect(
+          (sql as dynamic).sql,
+          'SELECT * FROM test_models WHERE name = @p0;',
+        );
+        expect(params, {'p0': 'Test'});
+      });
+
       test(
           'should return paginated response with hasMore true when limit is exceeded',
           () async {
@@ -524,6 +556,68 @@ void main() {
           throwsA(isA<InvalidInputException>()),
         );
       });
+
+      test('should throw BadRequestException on foreign key violation', () {
+        final exception = FakeServerException(
+          message: 'foreign key violation',
+          code: '23503',
+        );
+        when(
+          () => mockConnection.execute(
+            any(),
+            parameters: any(named: 'parameters'),
+          ),
+        ).thenThrow(exception);
+
+        expect(
+          () => sut.readAllByQuery({}),
+          throwsA(isA<BadRequestException>()),
+        );
+      });
+
+      test('should throw OperationFailedException on generic PgException', () {
+        final exception = PgException('generic connection error');
+        when(
+          () => mockConnection.execute(
+            any(),
+            parameters: any(named: 'parameters'),
+          ),
+        ).thenThrow(exception);
+
+        expect(
+          () => sut.readAllByQuery({}),
+          throwsA(isA<OperationFailedException>()),
+        );
+      });
+
+      test(
+          'should throw OperationFailedException on unknown ServerException code',
+          () {
+        final exception = FakeServerException(
+          message: 'some other server error',
+          code: 'XXXXX',
+        );
+        when(
+          () => mockConnection.execute(
+            any(),
+            parameters: any(named: 'parameters'),
+          ),
+        ).thenThrow(exception);
+
+        expect(
+          () => sut.readAllByQuery({}),
+          throwsA(isA<OperationFailedException>()),
+        );
+      });
+
+      test('should rethrow generic Exception for unknown errors', () {
+        final exception = Exception('a completely unknown error');
+        when(() => mockConnection.execute(any(), parameters: any(named: 'parameters')))
+            .thenThrow(exception);
+
+        expect(() => sut.readAllByQuery({}),
+            throwsA(isA<Exception>().having((e) => e.toString(), 'toString', contains('An unknown error occurred'))));
+      });
     });
   });
 }