Mapping raw query to entities

Issue type:

[ ] bug report [x] feature request [ ] documentation issue

Database system/driver:

[ ] cordova [ ] mongodb [ ] mssql [ ] mysql / mariadb [ ] oracle [x] postgres [ ] cockroachdb [ ] sqlite [ ] sqljs [ ] react-native [ ] expo

TypeORM version:

[ ] latest [x] @next [ ] 0.x.x (or put your version here)

Steps to reproduce or a small repository showing the problem:

Hello, I’ve been using typeorm for a while and I like it a lot, working with entities adds a lot of convenience.
I use a transformer on my entity classes to conveniently map values when reading/writing from the DB, however this only works if entities are obtained from the query builder or entity manager.

Right now there is no way to simply map a raw query to entities, however sometimes raw queries are a valuable escape hatch that will always be required in some cases, some being more common than others.
Right now I need the UNION operator which is fairly commonly used in SQL but not supported by typeorm (#2992).

I can use Object.assign or similar ways to manually map rows (like #1175), but this won’t apply my transformers (and possibly other typeorm specific stuff declared by annotations).

I suggest exposing some API which would at least allow for mapping a single row to an entity so that there is some way to keep using typeorm annotations while still being able to use unsupported SQL.

[pasalino]

I think this is a necessary feature. There isn’t any manner to query a huge quantity of rows. The single way to perform that is to use stream but if I haven’t mapped Entity what is the advantage to use ORM? It’s a standard feature in many ORMs for instance Prisma. Please think to implement it.

[sgarner]

TypeORM has RawSqlResultsToEntityTransformer which can help with this mapping. The catch is that you need to pass a QueryExpressionMap instance to it which might be difficult to build manually.

However if you are able to define all your selected columns and joins etc using QueryBuilder and then modify the resulting query with your custom SQL requirements, then this will provide the QueryExpressionMap for you. I would imagine a UNION would be an applicable use case here if you can build at least one of the component queries using QueryBuilder and use string manipulation to combine them into a UNION.

For example in my use case I needed to use a locking mode in SQL Server that is not currently supported by TypeORM. I was able to create my query using QueryBuilder and then modify the lock expression in the SQL before executing it as a raw query. Then transform that into entities using RawSqlResultsToEntityTransformer.

Here is the code:

import { FindOptionsUtils } from 'typeorm';
import { RelationCountLoader } from 'typeorm/query-builder/relation-count/RelationCountLoader';
import { RelationIdLoader } from 'typeorm/query-builder/relation-id/RelationIdLoader';
import { RawSqlResultsToEntityTransformer } from 'typeorm/query-builder/transformer/RawSqlResultsToEntityTransformer';

const qb = entityManager
  .getRepository(ExampleEntity)
  .createQueryBuilder('e')
  .setLock('pessimistic_write');

FindOptionsUtils.applyOptionsToQueryBuilder(qb, {
  relations: ['foobar'],
  where: {
    foo: 'bar',
  },
  order: {
    id: 'ASC',
  },
});

let [query, parameters] = qb.getQueryAndParameters();

// 👇 Here is where you can modify the SQL for the query to suit your requirements
query = query.replace(/ WITH \(UPDLOCK, ROWLOCK\) /, ' WITH (UPDLOCK, READPAST) ');

// Execute the SQL and get raw results
const rawResults = await entityManager.query(query, parameters);

const queryRunner = entityManager.connection.createQueryRunner();
const relationIdLoader = new RelationIdLoader(
  entityManager.connection,
  queryRunner,
  qb.expressionMap.relationIdAttributes,
);
const relationCountLoader = new RelationCountLoader(
  entityManager.connection,
  queryRunner,
  qb.expressionMap.relationCountAttributes,
);
const rawRelationIdResults = await relationIdLoader.load(rawResults);
const rawRelationCountResults = await relationCountLoader.load(rawResults);
const transformer = new RawSqlResultsToEntityTransformer(
  qb.expressionMap,
  entityManager.connection.driver,
  rawRelationIdResults,
  rawRelationCountResults,
  queryRunner,
);

// Transform the raw results into entities
const examples = transformer.transform(rawResults, qb.expressionMap.mainAlias);