Hirdetés

Új hozzászólás Aktív témák

  • nyunyu
    félisten

    Megcsináltam így, működik is szépen, aktívak az indexelések is.

    Viszont így már nem tudom ugye duplikálni a rekordokat, mert a másik táblában (ahol a rekordokhoz tartozó kategóriák vannak tárolva) már nem lehet olyan könnyen.
    Szóval most egyelőre 159 rekord van.

    És amiért most írok:
    Összehasonlításként futtatom a régi lekérdezést (LIKE '%category%' stb.) és az új lekérdezést (JOIN).

    És az a régi:
    - egyrészt dupla olyan gyors (sőt, 0.0112 vs 0.0266 seconds),
    - másrészt az Explain szerint csak a szükséges 4 rekordot ellenőrzi/használja (rows: 4) az indexelés miatt (a 159 helyett).

    Hogy van ez akkor?
    A sebesség talán most még az alacsony rekord szám miatt lehet, később, sokkal több elemnél ez talán majd fordul?
    Viszont Ti is azt írtátok, és én is azt találtam, hogy ha a LIKE operátor %sztring formában van használva, akkor a teljes táblát használja.
    Itt akkor rows: 4 helyett nem rows: 159-nek kellene lennie?

    Bocsánat a sok kérdésért, de ha már így alakult, hogy saját kezüleg kell csinálnom, szeretném érteni a miérteket. És köszönöm, ha válaszoltok, tanácsot adtok.
    (És továbbra is szívesen fizetnék a segítségért, a mostani struktúra átnézéséért, módosítására javaslatért, tanácsokért stb., csak hogy biztos lehessek az erős és stabil alapban.)

    Köszönöm.

    Sokszorozás:
    - Végigmész egy kurzorral a termék táblán, megjegyzed az eredeti adatait.
    - kiosztasz neki egy új azonosítót
    - beszúrsz egy új termék rekordot az eredeti adataival, csak id helyére az újat írod
    - leválogatod a termék_kategoria táblából az eredeti terméked kategória értékeit
    - beszúrod a termék_kategóriába az új termék_id, régi_kategória_id párosokat
    - tetszés szerint ismétled

    -- sokszorozás
    declare
    regi_id number;
    regi_name varchar2(100);
    uj_id number;
    i number;
    cursor cur is
    select p.id,
    p.name
    from product p
    where instr(p.name,'_') = 0;
    begin
    open cur;
    loop
    fetch cur into regi_id, regi_name;
    exit when cur%NOTFOUND;

    for i in 1..1000
    loop
    uj_id := product_seq.nextval;

    insert into product (id, name)
    values (uj_id, regi_name || '_' || to_char(i));

    insert into product_category (id, product_id, category_id)
    select product_category_seq.nextval,
    uj_id,
    pc.category_id
    from product_category pc
    where pc.product_id = regi_id;
    end loop;
    end loop;
    close cur;
    end;

    Próbáltam SQLFiddlében összerakni a múltkori gyümölcsös példámat, de valamiért nem tetszik neki a szintaxis.

    Hús-vér Oracle alatt persze simán legenerál 1000 új példányt minden termékből.

    Ha a DB kezelőd automatikusan inkrementálja az id mezőt (kb. mindenki, kivéve Oracle :W), akkor a for ciklus belsejében először beszúrod az új termék példányt, aztán leselectálod az id-jét az uj_id változóba, és úgy használod a termék_kategória beszúrásnál.

    Pl. SQL Serveren valahogy így

    ...
    while @i <= 1000
    begin
    insert into product (name)
    values (regi_name || '_' || convert(varchar(10),i));

    select p.id
    into @uj_id
    from product p
    where p.name = regi_name || '_' || convert(varchar(10),i));

    insert into product_category (product_id, category_id)
    select
    @uj_id,
    pc.category_id
    from product_category pc
    where pc.product_id = regi_id;

    set @i = @i +1;
    end;
    ..

    (Még jó, hogy mindenki másképp írja a szabvány SQLen felüli részt.)

Új hozzászólás Aktív témák