Vizsgajegyzetek

public static List<MintaClass> LoadFromJSON(string fileName = "minta.json") { var jsonText = File.ReadAllText(fileName); return JsonSerializer.Deserialize<List<MintaClass>>(jsonText) ?? new List<MintaClass>(); }

List<MintaClass> minta = new List<MintaClass>(); //lehet var is var minta = new List<MintaClass>(); try { minta = MintaClass.LoadFromJSON(); } catch { Console.WriteLine("Hiba"); }

public int Valami { get; set; } // nem lehet null → default: 0 public int? Valami { get; set; } // lehet null

• {x:F0} → nincs tizedesjegy
  Pl: 12.78 → 13
• {x:F1} → 1 tizedesjegy
  Pl: 12.78 → 12.8
• {x:F2} → 2 tizedesjegy
  Pl: 12.78 → 12.78
• {d:F} → teljes dátum és idő
  Pl: 2024. június 29. 14:30:00
• {d:d} → rövid dátum
  Pl: 2024.06.29.
• {d:t} → rövid idő formátum
  Pl: 14:30
• {d:T} → teljes idő formátum
  Pl: 14:30:00
• {d:yyyy.MM.dd HH:mm} → egyedi dátum + idő formátum
  Pl: 2024.06.29 14:30

Formázás példa

double x = 12.786;
DateTime d = DateTime.Now;

Console.WriteLine($"{x:F1}");
Console.WriteLine($"{d:yyyy.MM.dd HH:mm}");
  

Vizualizálva

12.786
   ↓ F1
12.8

2024.06.29 14:30:45
        ↓ yyyy.MM.dd HH:mm
2024.06.29 14:30
  

• Where(x => ...) → Szűrés feltétel alapján
  Pl: csak a 18 év felettiek → people.Where(p => p.Age >= 18)
• Select(x => ...) → Adatok átalakítása más formára
  Pl: csak neveket kérsz le → people.Select(p => p.Name)
• SelectMany(...) → Lista a listából → egy nagy lista
  [[1,2],[3,4]] => [1,2,3,4]
• OrderBy(x => ...) → Növekvő rendezés
  Pl: név szerint A-Z → people.OrderBy(p => p.Name)
• OrderByDescending(...) → Csökkenő rendezés
  Pl: legnagyobb pontszámtól → scores.OrderByDescending(x => x)
• GroupBy(x => ...) → Csoportosítás kulcs szerint
  Pl: diákok osztály szerint → students.GroupBy(s => s.Class)
• ToList() → IEnumerable → List
  Pl: módosítható lista kell → query.ToList()
• ToArray() → Tömbbé alakítás
  Pl: fix méretű tömb kell → query.ToArray()
• First() → Első elem
  Hiba, ha nincs elem → numbers.First()
• FirstOrDefault() → Első elem vagy default/null
  Biztonságosabb üres listánál → numbers.FirstOrDefault()
• Single() → Pontosan 1 elem kell
  Hiba, ha 0 vagy több van → users.Single(u => u.Id == 5)
• SingleOrDefault() → 0 vagy 1 elem lehet
  Hiba, ha több van → users.SingleOrDefault(u => u.Id == 5)
• Count() → Elemszám
  Pl: hány elem van? → numbers.Count()
• Sum(x => ...) → Összegzés
  Pl: fizetések összege → employees.Sum(e => e.Salary)
• Max() / Min() → Legnagyobb / legkisebb elem
  Pl: legmagasabb pont → scores.Max()
• Average() → Átlag számítás
  Pl: átlag életkor → people.Average(p => p.Age)
• Distinct() → Duplikátumok eltávolítása
  [1,1,2,2] => [1,2]
• Skip(n) → Első n elem kihagyása
  Pl: lapozás → numbers.Skip(10)
• Zip(a,b,(x,y)=>...) → Két lista párosítása
  ["A","B"] + [1,2] => A1,B2
• Join(...) → Két lista összekapcsolása kulcs alapján
  Pl: users + orders → users.Join(...)

LINQ folyamat vizuálisan

[összes ember]
       ↓ Where
[felnőttek]
       ↓ OrderBy
[rendezett felnőttek]
       ↓ Select
[csak nevek]
       ↓ ToList
[List<string>]

Példa pipeline

var result = people
    .Where(p => p.Age > 18)
    .OrderBy(p => p.Name)
    .Select(p => p.Name)
    .ToList();

var ertek = 0 do { try { ertek = szám_beolvasása; } catch { ertek = 0; } } while (ertek <= 0);

int[] numbers = { 1, 2, 3, 4 }; var pairs = numbers.Zip(numbers.Skip(1), (a, b) => a + " -> " + b); foreach (var item in pairs) Console.WriteLine(item); // This code produces the following output: // 1 -> 2 // 2 -> 3 // 3 -> 4

// lista?.Where(x => feltétel1 && feltétel2) // Rendezés .OrderBy(x => x.tulajdonsag) // További szűrés .Where(x => feltétel3) // Lista készítése .ToList() // Bejárás .ForEach(x => { Console.WriteLine($"{x.adat1} - {x.adat2}"); });

// Szöveg bekérés Console.Write("Szöveg: "); string text = Console.ReadLine(); // Egész szám bekérés Console.Write("Szám: "); int number = int.Parse(Console.ReadLine()); // Tört szám bekérés Console.Write("Érték: "); decimal value = decimal.Parse(Console.ReadLine().Replace(",", ".")); // Dátum bekérés Console.Write("Dátum: "); DateTime date = DateTime.Parse(Console.ReadLine());

var groups = lista .GroupBy(x => x.azonosito) .Select(g => new { id = g.Key, //esetleg id-k összehasonlítása elemek = g.OrderBy(x => x.valami).ToList() });

foreach (var item in lista) { var eredmeny = item.adatok .Zip(item.adatok.Skip(1), (a, b) => szamitas) .Max(); Console.WriteLine(eredmeny); }

Egy objektumhoz több kapcsolódó elem tartozhat

public virtual ICollection<PeldaClass> PeldaCollection { get; set; } = new List<PeldaClass>();

Az objektum egy másik objektumhoz tartozik

public virtual PeldaSzuloClass Szulo { get; set; } = null!;

ICollection → több kapcsolódó adat tárolása listában

new List<>() → üres lista létrehozása

Szulo → egyetlen kapcsolódó objektum

null! → az érték később lesz beállítva

Példa:

1 légitársaság → több járat 1 járat → 1 légitársaság

Scaffold-DbContext -Connection "server=localhost;database=adatbazis-nev;uid=root;pwd=;" -Provider Mysql.EntityFrameworkCore

<DataGrid Name="dgMinta" IsReadOnly="True" AutoGenerateColumns="False"> <DataGrid.Columns> <DataGridTextColumn Header="Id" Width="30" Binding="{Binding Id}"> </DataGrid.Columns> </DataGrid>

Binding="{Binding Date, StringFormat=yyyy.MM.dd HH:mm}" Binding="{Binding Price, StringFormat={}{0:# ###} Ft}" Binding="{Binding Adat, TargetNullValue='N/A'}"

private MintaContext dbContext = new MintaContext();

cboMinta.ItemSource = tömb változó ami feltölti ComboBox-t pl: adatok; cboMinta.DisplayMemberPath = Osztályban lévő mező megjelenítése pl: "Név"; cboMinta.SelectedValuePath = Osztályban lévő azonosító megadása pl: "Id"; cboMinta.SelectedIndex = hányadik elem legyen alapból kiválasztva pl: 0;

<ComboBox Name="cboMinta">

var adatok = dbContext.Set<MintaClass>().ToList(); dgMinta.ItemsSource = dbContext.Set<MintaClass>().ToList();

adatok.Insert(0, new MintaClass {});

// Ide írd a jegyzetet

// Ide írd a jegyzetet

Bootstrap főoldal
Bootstrap Grid Dokumentáció
Bootstrap Táblázatok Dokumentáció

// Ide írd a jegyzetet

// Ide írd a jegyzetet

Doksi: https://v20.angular.dev/guide/templates/binding

Szöveg: {{ valtozo }}

Tulajdonság: [tulajdonsag]="változó"

Esemény: (esemeny)="művelet"

Kétirányú: [(ngModel)]="változó"

Fontos: ngModel esetén FormsModule -t importálni kell hogy működjön

Doksi: https://v20.angular.dev/guide/components

@Component(...)

selector → HTML tag neve

imports → ide kerül modul / másik komponens

templateUrl → külön HTML fájl

változó → nev: tipus

függvény → muvelet()

betöltéskor → ngOnInit() - (ehhez az osztálynak implementálnia kell az OnInit-et)

Doksi: https://v20.angular.dev/guide/routing/router-reference

Sima út: routerLink="/utvonal"

Paraméterrel: ['/utvonal', id]

Aktív elem: routerLinkActive="classnev"

Fontos: RouterModule -t importálni kell hogy működjön

Doksi: https://v20.angular.dev/guide/routing/common-router-tasks

providers tömb

provideRouter(...)

provideHttpClient()

Doksi: https://v20.angular.dev/guide/routing/common-router-tasks

Sima: path + component

Paraméter: utvonal/:id

Wildcard: ** - (minden más path esetén)

Redirect: redirectTo

Vizsgán gyakori: wildcard mindig legalul

Doksi: https://v20.angular.dev/guide/http/making-requests

inject: inject(HttpClient)

Lista: get<Tipus[]>

Egy elem: get<Tipus>

Létrehozás: post<Tipus>

Módosítás: put<Tipus>

Törlés: delete()

Query param: HttpParams → set(...)

Doksi: https://v20.angular.dev/guide/http/making-requests

subscribe({ ... })

siker: next

hiba: error

navigálás: navigate([...])

Doksi: https://v20.angular.dev/api/core/Input https://v20.angular.dev/api/core/Output

Bemenet: @Input() változó

Kimenet: @Output() változó - (ennek egy új EventEmitter osztálypéldánynak kell lennie)

Esemény küldés: emit(érték)

Szülőből átadás: [adat]="változó"

Gyerek esemény figyelése: (esemény)="kezelő($event)"

import { create } from "zustand";

type GlobalStateData = {
  globalVariable?: string;
};

type GlobalStore = {
  gs: GlobalStateData;
  set: <K extends keyof GlobalStateData>(key: K, value: GlobalStateData[K]) => void;
};

export const useGlobalStore = create<GlobalStore>()((set) => ({
  gs: {
    globalVariable: "valami"
  },

  set: (key, value) =>
    set((state) => ({
      gs: {
        ...state.gs,
        [key]: value,
      },
    })),
}));

              useEffect(() => {
                async function MintaData() {
                  kód...
                }
                MintaData();
              }, []);
            

              "use client"
            

              export default function HomePage() {

                kód...

                return (
                  JSX kód tartalma... pl HTML tagek for ciklusok hívások stb
                )
              }
            

const { gs, set } = useGlobalStore();
set("globalVariable", "valami más");

Ez egy globális változó (bármelyik komponensben elérhető változó) értékét frissíti, gyakorlati haszna pl. UI state, light/dark mode, keresési paraméter

const [array, setArray] = useState<Model[]>([]);
setArray(apiLekeresResponse.data);

Ez a useState hook, amivel egy állapotváltozót hozol létre. Az array tartalmaz egy Model típusú tömböt, a setArray pedig egy függvény, amivel ezt az állapotot tudod később módosítani.

useEffect(() => {
  async function getData() {
    const parameter = gs.searchParameter ? gs.searchParameter : "*";
    const response = await axios.get(`url/${parameter}/valami`);
    setArray(response.data);
  }
  getData();
}, [dependencyValami]);

A useEffect hook minden alkalommal lefut, ha a "dependenyValami" frissül, üresen hagyott dependency array esetén csak az oldal betöltésekor fut le

// Ide írd a jegyzetet

Forrás: https://laravel.com/docs/13.x/routing#api-routes

php artisan install:api

Forrás: https://laravel.com/docs/13.x/eloquent

php artisan make:model ModelName -mc --api

Forrás: https://laravel.com/docs/13.x/migrations

php artisan make:migration create_table_name_table

Forrás: https://laravel.com/docs/13.x/migrations

php artisan migrate

Forrás: https://laravel.com/docs/13.x/migrations

php artisan migrate:refresh

Forrás: https://laravel.com/docs/13.x/migrations

php artisan migrate:fresh

Forrás: https://laravel.com/docs/13.x/migrations

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('flights', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('airline');
            $table->timestamps();
        });
    }
 
    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::drop('flights');
    }
};

Forrás: https://laravel.com/docs/13.x/eloquent

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model
{
    // ...
}

Forrás: https://laravel.com/docs/13.x/eloquent

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Member extends Model
{
    public $timestamps = false;

    protected $fillable = [
        'name',
        'flight_id',
        'age',
    ];
}

php artisan make:resource ResourceName

Forrás: https://laravel.com/docs/13.x/eloquent-resources

public function toArray(Request $request): array {
    return [
        'identifier'  => $this->id,
        'title_of_something'  => strtoupper($this->title),
        'things'   => ThingResource::collection($this->whenLoaded('things')),
    ];
}

Forrás: https://laravel.com/docs/13.x/eloquent-relationships#one-to-many

// "1" oldal:
public function posts() {
    return $this->hasMany(Post::class);
}
// "N" oldal:
public function user() {
    return $this->belongsTo(User::class);
}

Forrás: https://laravel.com/docs/13.x/eloquent-relationships#many-to-many

Song.php
public function playlists() { return $this->belongsToMany(Playlist::class) }

Playlist.php
public function songs() { return $this->belongsToMany(Song::class) }

Forrás: https://laravel.com/docs/13.x/seeding

public function run(): void
    {
        User::factory(10)->create(); // 10 user generálása a factory segítségével

        $user1 = User::create(['name' => 'Name1', 'email' => 'name1@domain.hu']);

        $post1 = Post::create([
            'user_id' => $user1->id,
            'title' => 'Title',
            'content' => 'Content'
        ]);

        Comment::create([
            'post_id' => $post1->id,
            'user_name' => 'Guest',
            'body' => 'Body'
        ]);
    }

 
namespace Database\Seeders;
 
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Str;
 
class DatabaseSeeder extends Seeder
{
    /**
     * Run the database seeders.
     */
    public function run(): void
    {
        DB::table('users')->insert([
            'name' => Str::random(10),
            'email' => Str::random(10).'@example.com',
            'password' => Hash::make('password'),
        ]);
    }
}

Forrás: https://laravel.com/docs/13.x/routing

Route::apiResource('songs', SongController::class);
// Ez létrehozza: GET /api/songs, POST /api/songs, GET /api/songs/{id}, stb.

Route::put('/comments/{comment}', [CommentController::class, 'update']);

Route::get('/user', [UserController::class, 'index']);

Doksi: https://learn.microsoft.com/aspnet/core/web-api

[ApiController]

[Route("api")]

öröklés: ControllerBase

adatbázis: AdatbazisContext

tipikus végpont: /api/...

Doksi: https://learn.microsoft.com/ef/core/querying/related-data/eager

[HttpGet("...")]

útvonal paraméter: [FromRoute]

query paraméter: [FromQuery]

kapcsolt tábla: .Include(...)

kapcsolt táblához extra kapcsolás: .ThenInclude(...)

szűrés: .Where(...)

alakítás: .Select(...)

nincs találat: NotFound(...)

siker: Ok(...)

Doksi: https://learn.microsoft.com/ef/core/querying/

[HttpGet(".../{id}")]

paraméter: [FromRoute]

keresés: .SingleOrDefault(...)

ha nincs: NotFound(...)

ha van: Ok(...)

Doksi: https://learn.microsoft.com/aspnet/core/web-api

[HttpPost("...")]

body: [FromBody]

JSON → objektum: JsonSerializer.Deserialize<Tipus>(...)

hozzáadás: .Add(...)

mentés: SaveChanges()

sikeres létrehozás: StatusCode(201,...)

hibás kérés: BadRequest(...)

Doksi: https://learn.microsoft.com/ef/core/saving/basic

[HttpPut(".../{id}")]

keresés: .SingleOrDefault(...)

módosítandó mezők: elem.Tulajdonsag = ...

frissítés: Update(...)

mentés: SaveChanges()

siker: Ok(...)

Doksi: https://learn.microsoft.com/ef/core/saving/basic

[HttpDelete(".../{id}")]

keresés: .SingleOrDefault(...)

törlés: .Remove(...)

mentés: SaveChanges()

válasz: Ok(...) vagy NoContent()

Doksi: https://learn.microsoft.com/ef/core/dbcontext-configuration/

öröklés: DbContext

táblák: DbSet<Tipus>

kapcsolat: OnConfiguring(...)

adatbázis: UseMySQL(...)

Doksi: https://learn.microsoft.com/ef/core/modeling/

egyedi index: .HasIndex(...).IsUnique()

összetett index: .HasIndex(x => new { ... })

kezdő adatok: .HasData(...)

Doksi: https://learn.microsoft.com/dotnet/api/system.text.json.jsonserializer

fájl olvasás: File.ReadAllText(...)

lista deszerializálás: Deserialize<List<Tipus>>(...)

betöltés: .HasData(...)

Doksi: https://learn.microsoft.com/ef/core/modeling/entity-properties

táblanév: [Table("...")]

kötelező: [Required]

max hossz: [StringLength(...)]

értéktartomány: [Range(...)]

oszloptípus: [Column(TypeName = "...")]

kapcsolat: SzerzoId + navigációs property

nem adatbázis mező: [NotMapped]

            request: NextRequest, { params }: { params: Promise<{ id: string }> }    

export async function GET() {
    const data = await prisma.table.findMany({});
    // + hibakezelés
}

export async function GET(//dinamikus végpont, urlből szedd ki az id-t) {
    const { id } = await params;
    const data = await prisma.table.findUnique({
      where: { id: Number(id) },
    });
  // + hibakezelés
}

                const body = await request.json();
                const newOne = await prisma.table.create({
                  data: body,
                });
    // + hibakezelés

export async function PATCH(//url-ből id kinyerése) {
    //konkrétan ugyanaz mint a POST, csak ne createlj, hanem update-t használj, illetve awaiteld az id-t a paraméterből és arra keress a where operátorral
    // + hibakezelés
}

export async function PUT(// url-ből id kinyerése) {
        //ugyanaz mint a PATCH
        // + hibakezelés
  }
}

export async function DELETE(//url-ből id kinyerése) {
    //olyan mint a GET by id, csak itt delete prisma operátor
    return new NextResponse(null, { status: 204 }); // ha nem kér a feladat semmilyen válaszüzenetet, akkor simán null az első paraméter
    // + hibakezelés
}

  
      const resWithNewData = res.map((e, i) => ({
    ...e,
    index: `${i + 1}.`,
  }));
  // utána ezt return nextrespone-ba, mint mindenhol máshol
  

if not exist "c:\data\" mkdir "c:\data"
if not exist "c:\data\db" mkdir "c:\data\db"
"c:\Program Files\MongoDB\Server\8.2\bin\mongod.exe" --dbpath="c:\data\db" --replSet "rs0"

if exist "C:\data" (
    rmdir /s /q "C:\data"
)

tar -xf data.zip -C C:\
pause

1. JSON fájlok megírása
2. extract-data
3. startMongoDb.bat
4. mongo.bat
5. npx prisma db pull --force
6. schema szerkesztése
7. npx prisma db push

[
  {
    "_id": 1,
    "unique_something": "alpha",
    "default_something": "default value"
  },
  {
    "_id": 2,
    "unique_something": "beta",
    "default_something": "custom value"
  }
]

[
  {
    "_id": 1,
    "date": {
      "$date": "2026-04-29T00:00:00.000Z"
      // ISO formátumú dátum, a MongoDB ezt így értelmezi majd, és a Prisma is jól fogja kezelni a @db.Date használatával
    },
    "relation_id": 1
  },
  {
    "_id": 2,
    "date": null,
    "relation_id": 2
  }
]

@echo off
chcp 65001
"mongoimport.exe" --uri="mongodb://localhost:27017" --db=dbname --collection=collectionname --drop --file=filename.json --jsonArray
"mongoimport.exe" --uri="mongodb://localhost:27017" --db=dbname --collection=collectionname --drop --file=filename.json --jsonArray
echo PLEASE KILL AND RESTART YOUR BACKEND SERVER DEV TASK IF RUNNING!

DATABASE_URL="mongodb://localhost:27017/dbname"

npx prisma db pull --force

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

model Collection1 {
  id                Int    @id @map("_id")
  unique_something  String @unique
  default_something String @default("default value")

  viewpoints Collection2[]

  @@index([default_something])  //keresésnél gyorsabb adatelérés - nem kötelező
  @@map("collection1name")
}

model Collection2 {
  id          Int       @id @map("_id")
  date        DateTime? @default(now()) @db.Date
  relation_id Int

  location Collection1? @relation(fields: [relation_id], references: [id])

  @@map("collection2name")
}

1:N kapcsolat (egy a többhöz)

Jelentése:
Egy rekordhoz több másik rekord tartozhat,
de a másik oldal egy rekordja csak egyhez kapcsolódhat.

Példa:
1 kategóriához több ingatlan tartozhat,
de 1 ingatlan csak 1 kategóriához tartozik.

────────────────────────────

Prisma szabály:

Az "N" oldalon van:
- a foreign key mező
- a @relation kapcsolat

Példa:
kategoria_id Int

kategora Kategora? @relation(fields: [kategoria_id], references: [id])

────────────────────────────

Az "1" oldalon van:
- a virtuális tömb mező

Példa:
ingatlanok Ingatlan[]

────────────────────────────

Mit jelent a virtuális mező?

Nem valódi adatbázismező.
A Prisma automatikusan kezeli.
Arra szolgál, hogy egyszerűen el lehessen érni
az összetartozó rekordokat.

────────────────────────────

  try {

        kód...

      } catch (error) {
        return NextResponse.json(
          { message: error instanceof Error ? error.message : "Ismeretlen hiba!" },
          { status: 500 },
        );
      }
    

            ### 6. feladat: A megadott járműtípussal elérhető utak lekérdezése
GET http://localhost:3000/api/journeys/112

### 7. feladat: Új utazási ajánlat hozzáadása
POST http://localhost:3000/api/journeys
content-type: application/json
# Request body tartalma: (A következő üres sort ne törölje ki!) 

{ 
   "id": 12345, 
   "vehicle_id": 1, 
   "description": "A festői szépségű német főváros…", 
   "departure": "2022-08-10T00:00:00.000Z", 
   "pictureUrl": "https://pictures.com/berlin.jpg" 
} 

### 8. feladat: Utazási ajánlat törlése id alapján
DELETE http://localhost:3000/api/journeys/333
  

            request: NextRequest, { params }: { params: Promise<{ id: string }> }    

            export async function GET()  

            ### 6. feladat: A megadott járműtípussal elérhető utak lekérdezése
GET http://localhost:3000/api/journeys/112

### 7. feladat: Új utazási ajánlat hozzáadása
POST http://localhost:3000/api/journeys
content-type: application/json
# Request body tartalma: (A következő üres sort ne törölje ki!) 

{ 
   "id": 12345, 
   "vehicle_id": 1, 
   "description": "A festői szépségű német főváros…", 
   "departure": "2022-08-10T00:00:00.000Z", 
   "pictureUrl": "https://pictures.com/berlin.jpg" 
} 

### 8. feladat: Utazási ajánlat törlése id alapján
DELETE http://localhost:3000/api/journeys/333
  

  } catch (error) {
    if (error instanceof Error && error.message.includes("Mintaszöveg")) {
      return NextResponse.json({ message: "Mintaszöveg" }, { status: feladatban meghatározott hibaüzenet pl: 404 });
    }
    

npx prisma db push

// példa 1 - egyszerű lekérés
const example1 = await prisma.exampleModel.findMany()

// példa 2 - where használata
const example2 = await prisma.exampleModel.findMany({
  where: {
    exampleField: "value"
  }
})

// példa 3 - select használata
const example3 = await prisma.exampleModel.findMany({
  select: {
    exampleField: true
  }
})

// példa 4 - create
const example4 = await prisma.exampleModel.create({
  data: {
    exampleField: "value"
  }
})

// példa 5 - update
const example5 = await prisma.exampleModel.update({
  where: {
    id: 1
  },
  data: {
    exampleField: "newValue"
  }
})

// példa 6 - delete
const example6 = await prisma.exampleModel.delete({
  where: {
    id: 1
  }
})

where - itt adsz meg feltételeket pl. id: 1 vagy name: "John"

data - itt adod meg a létrehozandó vagy módosítandó adatokat pl. name: "Anna"

select - megadod, hogy mely mezőket akarod visszakapni pl. { id: true, name: true }

include - kapcsolt (relációs) adatokat kérsz le pl. { posts: true }

omit - megadod, mit NE adjon vissza pl. { password: true }

orderBy - rendezés pl. { createdAt: "desc" }

take - hány rekordot kérsz le (limit) pl. 10

skip - hány rekordot hagyjon ki (offset) pl. 5

distinct - csak egyedi értékeket ad vissza pl. ["email"]

create - új kapcsolt rekord létrehozása relációban

update - kapcsolt rekord frissítése

upsert - ha létezik frissít, ha nem, létrehoz

delete - rekord törlése

deleteMany - több rekord törlése feltétel alapján

updateMany - több rekord frissítése feltétel alapján

createMany - több rekord létrehozása egyszerre

count - megszámolja a rekordokat