मेरे पास 3 इकाइयां हैं उपयोगकर्ता, स्पॉट और थिंग। एक यूजर के पास कई स्पॉट हो सकते हैं और एक स्पॉट में कई चीजें हो सकती हैं।

वर्तमान में मैं दो प्रश्न लिख रहा हूं, एक यह सत्यापित करने के लिए कि उपयोगकर्ता पर स्थान मौजूद है और फिर एक स्थान से चीजें प्राप्त करने के लिए। (देखें index.js)।

user.id और spot.id के आधार पर सभी चीजों का चयन करने के लिए मैं createQueryBuilder (repo.find का उपयोग न करके) का उपयोग करके एक प्रश्न कैसे लिख सकता हूं? मुझे पता है कि इसमें कुछ शामिल होना शामिल है, लेकिन मैं इसके चारों ओर अपना सिर नहीं लपेट सकता।

यह कोड का प्रासंगिक हिस्सा है:

const spot = await spotRepo.createQueryBuilder('spot')
  .innerJoin('spot.user', 'user')
  .where('user.id = :id', { id: 1 })
  .andWhere('spot.id = :id', { id: 1 })
  .getOne();
if (spot !== undefined) {
  console.log(spot);
  console.log('Got the spot');
  const spotWithThings = await spotRepo.createQueryBuilder('spot')
    .leftJoinAndSelect('spot.things', 'things')
    .where('spot.id = :id', { id: spot.id })
    .getOne();
  console.log(spotWithThings);
}

इस परियोजना को चलाने के लिए कदम:

  1. git clone https://github.com/fabianmoronzirfas/typeorm-how-to-write-smarter-queries-questionmark.git ./test-repo && cd test-repo
  2. npm i कमांड चलाएँ
  3. डेटाबेस सेटिंग को ormconfig.json फ़ाइल के अंदर सेट करें
  4. डेटाबेस शुरू करें docker-compose up
  5. npm start कमांड चलाएँ

यह index.ts है

import "reflect-metadata";
import { createConnection, getRepository } from "typeorm";
import { User } from "./entity/User";
import { Spot } from './entity/Spot';
import { Thing } from './entity/Thing';

createConnection().then(async connection => {
    {
        console.log("Inserting a new data into the database...");
        const user = new User();
        const spot = new Spot();
        // const things = [];
        for (let i = 0; i < 5; i++) {
            const thing = new Thing();
            if (spot.things === undefined) {
                spot.things = [thing];
            } else {
                spot.things.push(thing);
            }
            await connection.manager.save(thing);;
        }
        user.spots = [spot];
        await connection.manager.save(user);
        await connection.manager.save(spot);
        console.log('setup done');
    }
    const spotRepo = getRepository(Spot);
    const spot = await spotRepo.createQueryBuilder('spot')
    .innerJoin('spot.user', 'user')
    .where('user.id = :id', { id: 1 })
    .andWhere('spot.id = :id', {id: 1})
    .getOne();
    if (spot !== undefined) {
        console.log(spot);
        console.log('Got the spot');
        const spotWithThings = await spotRepo.createQueryBuilder('spot')
        .leftJoinAndSelect('spot.things', 'things')
        .where('spot.id = :id', { id: spot.id })
        .getOne();
        console.log(spotWithThings);
    } else {
        console.log(`No spot? with user id ${1}`);
    }
}).catch(error => console.log(error));

यह Spot.ts है।

import {Entity, PrimaryGeneratedColumn, Column, ManyToOne, OneToMany} from "typeorm";
import { User } from './User';
import { Thing } from './Thing';
@Entity()
export class Spot {
    @PrimaryGeneratedColumn()
    id: number;
    @ManyToOne( _type => User, user => user.spots)
    public user: User;
    @OneToMany(_type => Thing, (thing) => thing.spot, {
        eager: true,
      })
      public things!: Thing[];
}

यह बात है

import {Entity, PrimaryGeneratedColumn, ManyToOne, JoinColumn} from "typeorm";
import { Spot } from './Spot';

@Entity()
export class Thing {

    @PrimaryGeneratedColumn()
    id: number;

    @ManyToOne( _type => Spot, spot => spot.things , {
        cascade: true,
        // eager: true,
      })
      @JoinColumn()
      public spot!: Spot;
}

यह User.ts है

import {Entity, PrimaryGeneratedColumn, OneToMany} from "typeorm";
import { Spot } from './Spot';

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;
    @OneToMany(_type => Spot, spot => spot.user, {
        cascade: true,
      })
      public spots: Spot[];
}

यह है ormconfig.json

{
   "type": "postgres",
   "host": "127.0.0.1",
   "port": 5432,
   "username": "postgres",
   "password": "postgres_password",
   "database": "postgres",
   "synchronize": true,
   "dropSchema": true,
   "logging": false,
   "entities": [
      "src/entity/**/*.ts"
   ],
   "migrations": [
      "src/migration/**/*.ts"
   ],
   "subscribers": [
      "src/subscriber/**/*.ts"
   ],
   "cli": {
      "entitiesDir": "src/entity",
      "migrationsDir": "src/migration",
      "subscribersDir": "src/subscriber"
   }
}

यह मेरा docker-compose.yml है

version: '3'
services:
  postgres:
    container_name: 'pgdb'
    image: 'mdillon/postgis:10'
    ports:
      - '5432:5432'

यह पैकेज है।जेसन

{
   "name": "typeorm-smarter-req",
   "version": "1.0.0",
   "description": "",
   "main": "index.js",
   "scripts": {
      "test": "echo \"Error: no test specified\" && exit 1",
      "start": "ts-node src/index.ts"
   },
   "author": "",
   "license": "ISC",
   "dependencies": {
      "pg": "^7.11.0",
      "reflect-metadata": "^0.1.10",
      "typeorm": "0.2.18"
   },
   "devDependencies": {
      "ts-node": "3.3.0",
      "@types/node": "^8.0.29",
      "typescript": "3.3.3333"
   }
}

यह tsconfig.json है

{
   "compilerOptions": {
      "lib": [
         "es5",
         "es6",
         "dom"

      ],
      "target": "es5",
      "module": "commonjs",
      "moduleResolution": "node",
      "outDir": "./build",
      "emitDecoratorMetadata": true,
      "experimentalDecorators": true,
      "sourceMap": true
   }
}
1
fabianmoronzirfas 27 जून 2019, 14:34

1 उत्तर

सबसे बढ़िया उत्तर

आप चीजों को लाना चाहते हैं, इसलिए थिंग रेपो से शुरू करें और प्रश्न को कई प्राप्त करने के लिए कहें, जो कि परिभाषाओं में शामिल होने के आधार पर बाधाओं द्वारा फ़िल्टर किया गया है:

const thingRepo = entityManager.getRepository(Thing);
const things = thingRepo.createQueryBuilder('thing')
    .leftJoinAndSelect('thing.spot', 'spotThing')
    .leftJoinAndSelect('spotThing.user', 'userSpot')
    .where('spotThing.id = :spotId', {spotId})
    .andWhere('userSpot.id = :userId', {userId})
    .getMany();
3
zenbeni 1 जुलाई 2019, 16:32