DEV Community: Anoop Singh

C++ vs. Rust: A Comparative Guide to Syntax, Variables, and Control Flow

Anoop Singh — Sun, 22 Sep 2024 03:30:01 +0000

Hello World

C++ Version:

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Rust version:

fn main() {
    println!("Hello, World!");
}

Variables and datatypes:

C++ version:

#include <iostream>

int main() {
    int x = 5;
    double y = 3.14;
    std::cout << "x: " << x << ", y: " << y << std::endl;
    return 0;
}

Rust version :

fn main() {
    let x: i32 = 10; // here i32 is a 32-bit integer
    let y = 22; // Rust can infer the type from given value
    let z: f32 = 30.0;
    x = x + 1; // This will throw an error because x is immutable
}

In rust variable are immutable by default

To make them mutable

fn main() {
    let mut x= 5;
    x = x + 1;
    println!("x: {}", x);
}

But immutable doesn’t means they are constant -

fn main() {
    let x = 5;
    let x = 10; // You can shadow the variable
    println!("x: {}", x);
}

Why need such functionality?

fn main() {
    let s = "hello ";
    let s = s.trim(); // No need to create a new variable
    println!("s: {}", s); 
}

Functions:

C++ version

int add(int a, int b) {
    return a + b;
}

int main() {
    std::cout << "Sum: " << add(5, 3) << std::endl;
    return 0;
}

Rust version

fn add(a: i32, b: i32) -> i32 { // Type required
    a + b // Note - semicolon is omitted   
}

fn main() {
    println!("Sum: {}", add(5, 3));
}

Conditionals

C++ version

int main() {
    int number = 10;

    if (number > 5) {
        std::cout << "Number is greater than 5." << std::endl;
    } else if (number == 5) {
        std::cout << "Number is equal to 5." << std::endl;
    } else {
        std::cout << "Number is less than 5." << std::endl;
    }

    return 0;
}

Rust version;

fn main() {
    let number = 10;

    if number > 5 {
        println!("Number is greater than 5.");
    } else if number == 5 {
        println!("Number is equal to 5.");
    } else {
        println!("Number is less than 5.");
    }
}

Loops

C++ version

int main() {
    for (int i = 0; i < 5; ++i) {
        std::cout << "Iteration: " << i << std::endl;
    }

    int j = 0;
    while (j < 5) {
        std::cout << "While Iteration: " << j << std::endl;
        j++;
    }

    return 0;
}

Rust version:

int main() {
    for i in 0..5 {
        println!("Iteration: {}", i);
    }

   let mut count = 0;
    loop {
        count += 1;
        println!("{}", count);
        if count > 10 {
            break; 
        }
    }

    let mut j = 0;
    while j < 5 {
        println!("While Iteration: {}", j);
        j += 1;
    }
}

How to integrate Drizzle ORM with Nest Js

Anoop Singh — Tue, 17 Sep 2024 13:53:04 +0000

This tutorial is for how to integrate Dirzzle orm with Nest js. The example uses postgres as connection database

Add Database url to env file -

# DATABASE_URL='postgresql://<host>:<password>@localhost:5432/<database>'

If you encounter some problems regarding connecting to database use these -

# DATABASE_URL='postgresql://<host>:<password>@localhost:5432/<database>?sslmode=require&connect_timeout=10&pool_timeout=15

Create drizzle.config.ts file inside root folder

import { defineConfig } from 'drizzle-kit';
export default defineConfig({
  dialect: 'postgresql',
  schema: './src/schema.ts',
  out: './drizzle',
  dbCredentials: {
    url: process.env.DATABASE_URL,
  },
});

Create schema file inside root directory -

//schema.ts
import {
  pgTable,
  pgEnum,
  serial,
  timestamp,
  text,
  integer,
  primaryKey,
  boolean,
  uuid,
} from 'drizzle-orm/pg-core';
import { InferSelectModel } from 'drizzle-orm';

export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  authorId: integer('author_id')
    .notNull()
    .references(() => users.id, {
      onDelete: 'cascade',
      onUpdate: 'no action',
    }),
  content: text('content'),
  mediaUrl: text('media_url'),
  createdAt: timestamp('created_at').notNull().defaultNow(),
  updatedAt: timestamp('updated_at').notNull().defaultNow(),
});

Create a drizzle.provider.ts file inside drizzle repository folder-

//drizzle.provider.ts
import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';
import * as schema from '../../schema';
import { ConfigService } from '@nestjs/config';
import { NodePgDatabase } from 'drizzle-orm/node-postgres';

export const DrizzleAsyncProvider = 'DrizzleAsyncProvider';

export const drizzleProvider = [
  {
    provide: DrizzleAsyncProvider,
    inject: [ConfigService],
    useFactory: async (configService: ConfigService) => {
      const connectionString = configService.get<string>('DATABASE_URL');
      const pool = new Pool({
        connectionString,
      });

      return drizzle(pool, { schema }) as NodePgDatabase<typeof schema>;
    },
  },
];

//drizzle.module.ts
import { Module } from '@nestjs/common';
import { DrizzleAsyncProvider, drizzleProvider } from './drizzle.provider';

@Module({
  providers: [...drizzleProvider],
  exports: [DrizzleAsyncProvider],
})
export class DrizzleModule {}

How to use it ?

//post.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { Inject } from '@nestjs/common';
import { NodePgDatabase } from 'drizzle-orm/node-postgres';
import * as sc from '../../schema';
import { DrizzleAsyncProvider } from 'src/core-modules/drizzle/drizzle.provider';
import * as q from 'drizzle-orm';

@Injectable()
export class PostService {
  constructor(
    @Inject(DrizzleAsyncProvider)
    private db: NodePgDatabase<typeof sc>,
    private cloudinaryService: CloudinaryService,
  ) {}

 async createPost(userId: number, createPostDto: CreatePostDto) {
    const [post] = await this.db
      .insert(sc.posts)
      .values({ authorId: userId, ...createPostDto })
      .returning();
    const [newpost] = await this.selectPostsWithAuthor(userId).where(
      q.eq(sc.posts.id, post.id),
    );
    return newpost;
  }

Inside package.json add

"scripts": {
    "generate": "drizzle-kit generate",
    "migrate": "drizzle-kit migrate",
    "studio": "drizzle-kit studio"
  },

Generate - create migration folder containing SQL code for the schema file you created

Migrate - apply those migrations

Studio - connect with the drizzle studio

Now run

npm run generate

Then,

npm run migrate