Sziasztok!

Hogyan, hány táblával lehetne azt megoldani, hogy:
-vannak felhasználók, különböző jogokkal (admin, user, stb). Ez nyilván 1 tábla.
-vannak folyamatai (aktív volt, fizetését kiutalták). Minden usernek külön folyamata van. Talán ez még belefér az user táblába (process 1,2,3...)?
-Es ezeket a folyamatokat havonta adminisztrálni.
-ha adott user adott havi minden folyamata aktív, adott hónapot aktívvá tenni. Tehát 1 hónapban adott user minden folyamat ok, akkor hónap is ok legyen végül.

Ezeket kellene táblázatban kezelni...
Én 2 vagy 3 táblára gondolok, de nem vagyok tervező, itt biztos, hogy van nálam sokkal okosabb,aki tudja, milyen szerkezettel lehetne ezt jól menedzselni.

Köszi a segítséget!

--- 2013...Ha valaki valami jó bizniszt tud, írjon rám mindenképp!!! ---

Miért szeretnél spórolni a táblákon?
Sokkal átláthatóbb lesz, és könnyebben bővíthető, ha külön fogalmakra külön tábla van.

Én 5 táblából indulnék ki:
- felhasználók (id, jog id, név... stb.*)
- jogok (id, név...)
- folyamat típusok (id, név...)
- folyamat állapotok (id, név...)
- folyamatok (id, felhasználó id, folyamat típus id, állapot id...)

*: állapot azonosító, létrehozás dátuma, egyéb szépségek

Esetleg külön állapot táblák a felhasználókra, jogokra is.

Köszönöm.
Nem szeretnék spórolni és nem egyedül csinálom (ez egy sulis feladat), csak elakadtunk.
De normálisan nem is volt megtervezve az adatbázis... És azt gondolom, ez itt az alapvető probléma. Mert, ha nincs alap, hogyan építkezzek?

Ez egy kis adatbázis lesz, kb 30 fő adatait tárolja.

De igazad van, így jobban kezelhető.
Név mellé a hónapokat (szept, okt, nov..) úgy kérdezem le/jelenítem meg (és módosítom, írom), hogy adott hónapra kérdezve jelenítem meg a folyamatok táblázatból az adatokat, létrehozás dátuma alapján?

Nah, délután összerakom valamennyire.

--- 2013...Ha valaki valami jó bizniszt tud, írjon rám mindenképp!!! ---

Sziasztok,

Az excel countif funkcióját mivel lehet megcsinálni sql-ben?
Van egy adathalmazom (párszázezer sor) ahol van egy oszlop amiben az érték többszöröződhet, ezt szeretném számolni a kritéria alapján.
Addig jó, hogy COUNT(CASE WHEN <condition> THEN 1 END)
Viszont nekem nem egy fixált kondíció kéne, hanem hogy adaptívan számolja, hogy melyik karaktersorozat hányszor szerepel (1x, 2x, 3x, 4x stb)

Ha a multiverzum teória igaz, akkor van egy univerzum, ahol nem az.

Mit jelent az adaptívan? Van egy táblád amiben vannak a keresendő karaktersorozatok?

JOGI NYILATKOZAT: A bejegyzéseim és hozzászólásaim a személyes véleményemet tükrözik; ezek nem tekinthetők a munkáltatóm hivatalos állásfoglalásának...

analitikus fuggvennyel:
count(*) over(partition by mezo) as ertek_db

Lehet bevettem némi fogalmazásgátlót

1 sor xxy
2 sor xxy
3 sor xyx
stb.

Azt szeretném, hogy számolja a az értéket, és mondjuk az xxy-t tartalmazó soroknál egy 2-es menjen minden sor végére, mert 2x szerepel, az xyx sor végére 1-es, ami 10x ugyanaz az érték, ott minden azt az értéket tartalmazó sor végére 10-es stb.

Mintha csak lehúznék egy countif-et végig rajtuk.

Ha a multiverzum teória igaz, akkor van egy univerzum, ahol nem az.

utolsó példa

Üdv,

adott egy tábla (cikktorzs_customer) amiben a cust_partnerkod hibás kód miatt több ezer rekord esetében azonos értéket vett fel (200000). Akarnék egy updatet az érintett rekordokra ami annyit csinál, h kiolvassa a mindig aktuálisan legnagyobb partnerkódot és ahhoz egyet hozzáad.

UPDATE cikktorzs_customer c_c, (SELECT cust_partnerkod AS i_c_p FROM cikktorzs_customer ORDER BY cust_partnerkod DESC LIMIT 1) i_c_c
SET `cust_partnerkod` = i_c_p + 1
WHERE c_c.cust_partnerkod = 200000

A gond ezzel annyi, h a belső select nem értékelődik ki újra minden alkalommal, így az összes rekord ami eddig 200000 volt, most 200001 lett. Ki tudja a megoldást?
Előre is köszi annak, aki

[ Szerkesztve ]

̿' ̿'\̵͇̿̿\з=(◕_◕)=ε/̵͇̿̿/'̿'̿ ̿

Javaslom a szabványos merge szintaxis tanulmányozását.

Sok fejfájástól megment, ha több tábla joinja alapján kell updatelni egy táblát...

Egyébként már az updateedet sem értem, miért kéne többször lefutnia az alselectnek, ha egyre limitáltad a visszaadható eredmény számát?
Meg a join feltétel is kompletten hiányzik, ami alapján leválogatnád, hogy melyik rossz sorhoz milyen jó partnerkód tartozna.

Ez most pont azt csinálja, hogy leválogatja a legnagyobb partnerkódot, és annyi+1-et ráupdatel minden 200000-es sorra.

Ezzel maximum annyit tudsz csinálni, hogy beteszed egy kurzorba az összes 200000-es sort, aztán egyesével végigiterálva rajtuk mindig eggyel nagyobb értékkel updateled őket.

Vagy valami nagyon elborult merget írsz, ami besorszámozza a sorokat, aztán az alapján updatel:
merge into cikktorzs_customer u
using (select cc.id, cc.cust_partnerkod, row_number() over (order by cc.id) rn
from cikktorzs_customer cc
where cc.cust_partnerkod = 200000) x
on (u.id = x.id)
when matched
then update set u.cust_partnerkod = x.cust_partnerkod + x.rn;

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

Ha meg nincs egyedi id mező a táblán, akkor így jártál.
(mentőövnek Oracle alatt ott a rowid, nem tudom többi DB alatt van-e ilyen rendszer szinten mindig egyedi sorazonosító)

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

"mentőövnek Oracle alatt ott a rowid, nem tudom többi DB alatt van-e ilyen rendszer szinten mindig egyedi sorazonosító" - mssql-nél nincs ilyen automatikusan, de bármikor tud generáltatni, ha kell.

Én kérek elnézést!

"Sok fejfájástól megment, ha több tábla joinja alapján kell updatelni egy táblát..." - de ez egy tábla ...

"Egyébként már az updateedet sem értem, miért kéne többször lefutnia az alselectnek, ha egyre limitáltad a visszaadható eredmény számát?" - azért, mert egy rekordhoz egyszer kell lefusson, de az első update után változik az adatnézet, ha akkor újra kiértékelődik a belső select, akkor már az eggyel növelt értékű rekordot kellene (mármint a logikám szerint) megtalálnia.

̿' ̿'\̵͇̿̿\з=(◕_◕)=ε/̵͇̿̿/'̿'̿ ̿

Selectnél működik:

SET @row_number = 1;
SELECT
(@row_number:=@row_number + 1) AS num,`cust_partnerkod`
FROM cikktorzs_customer WHERE `cust_partnerkod`= 200000

De update-nál nem, ugyanarra az értékre updateli az összes érintett sort:

SET @row_number = 1
UPDATE cikktorzs_customer c_c, (SELECT (@row_number:=@row_number + 1) AS num, cust_partnerkod AS i_c_p FROM cikktorzs_customer LIMIT 1 ) i_c_c SET `cust_partnerkod` = cust_partnerkod + @row_number WHERE cust_partnerkod = 200000

[ Szerkesztve ]

̿' ̿'\̵͇̿̿\з=(◕_◕)=ε/̵͇̿̿/'̿'̿ ̿

Akkor csináld kurzorral.

Én kérek elnézést!

azért, mert egy rekordhoz egyszer kell lefusson, de az első update után változik az adatnézet, ha akkor újra kiértékelődik a belső select, akkor már az eggyel növelt értékű rekordot kellene (mármint a logikám szerint) megtalálnia.

Írtál egy alselectet, aminek összesen 1 rekord az eredménye, és értelmes join feltétel híján sikerült Deschartes szoroznod a tábláddal, vagyis minden sorhoz ugyanazt az 1 értéket rendelte hozzá.

Ha az alselectednek nem 1 sor lett volna az eredménye, akkor DB errort kaptál volna, mert egy mezőnek nem lehet egyszerre több értéket adni.

Hello IT! Have you tried turning it off and on again?

""Sok fejfájástól megment, ha több tábla joinja alapján kell updatelni egy táblát..." - de ez egy tábla ..."

Meg kell határoznod, hogy
- melyik sorazonosítóhoz
- milyen értéket szeretnél rendelni.
Ezekből létrejön sok (id, érték) páros, ami kvázi egy újabb tábla/nézet/alselect, ezt kell összefésülnöd az eredeti tábláddal, az meg join művelet.

Hello IT! Have you tried turning it off and on again?

Hja, ha SQL Servert használsz akkor próbálkozhatsz az archaikus Teradata upsert szintaxissal is, hátha megeszi:
(Elvileg 2008R2-vel próbálták átcsábítani a Teradata DWH júzereit, aztán a legacy kód migráció megkönnyítésére implementálták a Teradata szintaxisát is.)

update cc
set cc.cust_partnerkod = cc.cust_partnerkod + x.rn
from cikktorzs_customer cc,
(select id, row_number() over (order by id) rn
from cikktorzs_customer
where cust_partnerkod = 200000) x
where cc.id = x.id;

(Hmm, MS csak a SET és a WHERE között engedi a FROM utáni tábla felsorolást? Teradatában a SET elé is lehetett írni, sőt legtöbbször úgy írták.)

De a feljebb írt mergenek biztosan működnie kéne, az a több táblát összefésülő műveletek szabványos írásmódja.
FROM clause nagyon nem szabványos az update szintaxisokban, nem sok DB ismeri, kezeli.
(Oracle alatt meg se próbáld!)

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

Köszi, közben meglett, sokkal egyszerűbb mint gondoltam:

SET @row_number = 1;
UPDATE cikktorzs_customer SET `cust_partnerkod` = 200000 + (@row_number := 1 + @row_number)
WHERE cust_partnerkod = 200000

̿' ̿'\̵͇̿̿\з=(◕_◕)=ε/̵͇̿̿/'̿'̿ ̿

Kicsit megkésve, de köszönöm szépen, ez jónak tűnik

Ha a multiverzum teória igaz, akkor van egy univerzum, ahol nem az.

Üdv!
mysql UNION-nál kellene nekem olyan megoldás, hogy az eredmény ne egy tábla több sor legyen, hanem egy sorba az összes eredmény (mondjuk vesszővel elválasztva) mint php alatt az implode.
van mondjuk 3 tábla amit union-al összefűzök. mindegyik táblából lekérem az ID-t.
Akkor az eredmény lesz egy ID tábla 3 értékkel.
Van erre valami megoldás, hogy egy sor legyen benne a 3 érték.
Fel szeretném használni egy másik lekérésbe ahol az IN-t fogom használni, csak ugye annak meg sorozat kell.
Azaz később lesz egy SELECT * FROM xy WHERE id IN ( ide jön az union-os összefűzés)
Így most ugye 3 lekérdezést futtatok, ezt szeretném egyre redukálni.

Köszi!

http://sb-soft.hu - "A" számlázó

Szabvány szerint az IN-nek el kell fogadnia egy alquery eredményét is, amennyiben pontosan egy oszlop széles az eredménye, szóval nem értem miért akarod vesszővel felsoroltatni az UNION eredményét, ahelyett, hogy szimplán beírnád az IN utáni zárójelek közé az egész UNIONos queryt.

Ez egy teljesen valid query:
select *
from tabla
where id in (select id from tabla2 where ertek = 1
union
select id from tabla3 where ertek = 2
union
select id from tabla4 where ertek = 3);

Végeredménye 0-3 sor lesz, attól függően hány ID van meg a tablaban.

(Oracle megenged több oszlop széles IN-t is, itt arra kell figyelni, hogy ugyanannyi oszlop legyen az IN két oldalán felsorolva:
where (a,b) in (select c,d from tabla); )

Amit te szeretnél, az maximum dinamikus SQLlel oldható meg, amikor futási időben rakod össze stringként a queryt, aztán azt futtatod az erre szolgáló paranccsal (EXEC?), de annak meg jellemzően van valamennyi futási idő overheadje (Oraclenál ~1.5 másodperc?), szóval nem éri a nehezen összerakható, nehezen debugolható kóddal szívni, mert nem lesz gyorsabb.

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

concat és concat_ws
és left joinnal teszed hozzá a plusz oszlopokat, nem unionnal

[ Szerkesztve ]

Sziasztok,

van egy táblám, amiben van kb 1000 adat
Van egy selectem, amibe ezt az 1000 adatot egyesével szeretném beillesztve lefuttatni, és az 1000 adattal lefutott eredményt szeretném kiexportálni.
Merre induljak el, mi lehet ilyenkor a megoldás? (Ja, oracle-t használnék )
Köszönöm előre is

[ Szerkesztve ]

Konkrétabban?

Én kérek elnézést!

Van egy selectem, amin kb így néz ki

Select *
From
Adattabla at
Where
at.azonosito = '1234'
Order by created_date asc
Fetch first 1 rows only;

Van egy temp táblám, amibe egy oszlop van csak amiben van 1000 azonosító, és ezt szeretném az 1234 helyére beilleszteni, lefuttatni, és az 1000 eredményt egyben látni. Remélem így érthetőbb voltam :)

IN operátor+alquery:
select *
from adattabla at
where at.azonosito in (select azonosito from temp);

De akár JOINnal is szűrhetsz:
select at.*
from adattabla at
join temp t
on t.azonosito = at.azonosito;

Régebben a JOINt javasolták a kétféle megoldás közül, mert az gyorsabb volt, manapság már nincs futási idő különbség, mert a (NOT) INt is (ANTI) JOINra fordítja a DB optimalizálója.

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

a dátum szerinti rendezés és első sor limit következményét nem írtad

Egy átlagos héten négy hétfő és egy péntek van (C) Diabolis

igen, de ez a sor limit miatt nem fog működni szerintem. Arra azért van szükségem, mert normál esetben 20 sort kapok vissza, de nekem csak az első kell.
Vagy nincs igazam?

közben megoldottam max min-el, így nem kellett a row limit. Köszi azért az ötletelést srácok

úgy jön ki az ezer sor, hogy van egy kapcsolótáblája, a temp, amiben van 1000 azonosító. ehhez akarja leválogatni a másik táblából minden azonosítóhoz a legkisebb dátumút.
tehát az eredeti kérdésben volt egy order by created date asc limit 1 is.

Egy átlagos héten négy hétfő és egy péntek van (C) Diabolis

Sziasztok

Az lenne a kérdésem hogy sqlserver 2017 alá régebbi sqlserver2008-ból az adatbázist file-t ha be importálom akkor az fog-e működni vagyis kompatbilis-e a új server régi adatbázissal?

Előre is köszi.

Attól függ, mi van a DB-ben. Szerintem többnyire igen a válasz.

Én kérek elnézést!

Nem túl valószínű, hogy ennyire régit be lehetne importálni.

Itt azt írják, hogy a 2012 támogatása is lejár idén júliusban, jelen pillanatban az a legrégebbi verzió, amit lehet 2019-re upgradelni.

Valószínűbb az, hogy a 2008-as DBdet fel kell upgradelned valami kevesebb, mint 10 évvel frissebbre (2016? 2017?), és csak onnan kiexportálva tudnád betenni egy aktuális verzió alá.

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

Azért az sem mindegy így első körben hogy sima backupról beszélünk vagy ténylegesen a db fájl attachról?

Mert db backupból simán tudod restoreolni a 2008as mentést a 2019-re is. Persze az ellenkező irány nemfog menni. És persze ha nincs benne semmi specialitás, esetleg a programozott részén már kivezetett ficsőrők, stb.

[ Szerkesztve ]

Má' nem

(Ubuntu 22/mysql 8)
Mi a különbség:
1. ssh promptból mysql -u root -p helyes jelszóval beenged.
2. ugyan ez a user/password elhelyezve a .my.cnf -benAccess denied for user 'root'@'localhost' (using password: YES)

A doksiban van mysql_config_editor ami felparaméterezve létrehozza .mylogin.cnf obfuszkálva. Így már működik.
Tele van a net a .my.cnf megoldással és az nekem sehogyan sem akart menni.

Sziasztok! Egy lekérdezéssel kapcsolatban lenne egy kérdésem. Egy dátumra kérdezek le úgy, hogy a dátum md5-el van kódolva. Ez így működik is, de csak így egy napot tudok lekérdezni.
SELECT * from tabla where md5(CAST(DATETIME AS DATE)) = 'ea88fe6807b44f248329a85debee3c58'Hogy lehetne lekérezni egy tartományra, hogy a kezdő és a záró dátumok ugyan így md5-ben vannak. Próbálgattam a BETWEEN utasítással, de nem tudom megcsinálni. Tudnátok ebben segíteni egy kicsit?

Nem teljesen értem, hogy mit is szeretnél.

MD5-tel kódolva van letárolva az időbélyeg, és azokra a bejegyzésekre akarsz szűrni amik X és Y dátumok közöttiek?

Az nem lesz egyszerű, mert a hash függvények irreverzibilisek, nem állítható belőlük vissza az eredeti érték, esetedben dátum.
Emiatt a <, >, between operátorokat nem tudod használni két hash érték direkt összehasonlítására.

Itt csak azt tudod tenni, hogy kigenerálod X és Y közötti összes dátum MD5 értékét, és azt vizsgálod, hogy az eredeti érték benne van-e ebben a halmazban.

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

Igazából az lenne a feladat, hogy egy webcímben GET kérés paramétereként adom meg a kezdő és a záró dátumot. Valahogy így:
http://weboldal.hu?id1=2022-07-10&id2=2022-07-20
De a lényege az lenne, hogy akinek megadom ezt a linket, az ne tudjon másik dátumra lekérdezni. Én a weboldalon legenerálok egy md5-ben lévő dátumot. Esetleg teszek még más karaktereket is mellé, hogy véletlenül se tudjon legenerálni másik dátumra kódot. (ha esetleg rájönne, hogy csak egy dátum van az md5-ben) Ezt elküldöm a felhasználónak. Ezért kellene valahogy így kódolni a paramétereket:
http://weboldal.hu?id1=ea88fe6807b44f248329a85debee3c58
Ez így egy dátumra való lekérdezéssel működik is, mert ott az adatbázisban minden sor dátumát át tudom alakítani md5-re és utána csak össze kell hasonlítani a webcímben kapott md5 értékkel. De nekem két dátum között található összes sort kellene lekérdeznem, amit így nem lehet.
Vagy esetleg van másmilyen bevált megoldás arra, hogy a GET kérés paraméterében lévő értékek manipulálásával ne tudjon mást lekérdezni a felhasználó?

Akkor használj valami olyan kódolást, ami szimmetrikus, vissza lehet fejteni.
Pl. base64.

Hello IT! Have you tried turning it off and on again?

Akkor inkább kitalálok valami egyedi kódolást.

Sziasztok!
Having helyett mit lehetne (ha lehet) az alábbiak megvalósítására? (Illetve van egy subselect is)
van egy rakat tábla, de csak a 3 fontosat említem
rendelés tábla (rendelés id, meg a szokásos dolgok)
tétel tábla (tétel_id, rendeles_id, kuldes_id, szamla_id)
user tábla (user_id, usernev, rendeles_tmp)

Ha valaki dolgozik akkor a rendelés id-t berakja az user tábla rendeles_tmp-be egy trigger.
Kellene egy lista amibe azon a rendelések vannak amin akad még tennivaló.
Ezt onnan tudjuk, hogy a kuldes vagy a szamla id a tételnél 0.

Most kb ez a lekérdezés:
SELECT T1.redeles_id,
min(T2.kuldes_id) AS kuldes_min,
min(T2.szamla_id) AS szamla_min
FROM rendeles AS T1
LEFT JOIN tetel AS T2 ON T1.rendeles_id=T2.rendeles_id
AND rendeles_id NOT IN (SELECT IFNULL(rendeles_tmp,0) FROM user)
GROUP BY T1.rendeles_id
HAVING kuldes_min=0 AND szamla_min=0

persze mint mondtam van még egy rakat tábla ami a fejléchez van joinolva, de azok nem lényegesek. Pl.: szállítási mód, fizetési mód stb.
A rendelés 35690 bejegyzés míg a tétel 116984.
A min és a having miatt kissé lomha a lekérdezés, azaz 1.22mp-et vár a kliens mire megkapja az adatokat.
Kérdésem, hogy lehet-e valamennyit gyorsítani valahogy?
Indexek természetesen vannak.

Köszi!

http://sb-soft.hu - "A" számlázó

Juj.

Először sorbarendezted+csoportosítottad a tételeket rendeles_id szerint, azután az ablakozós függvény a csoportokra külön-külön képezett egy eredményt, aztán az eredményhalmazt még egyszer átfésülted a having után írt feltételekkel?

Nem lenne egyszerűbb egy sima joinnal eleve azokra a tételekre szűrni, ahol a kuldes_id vagy szamla_id null?

SELECT DISTINCT T1.rendeles_id
FROM rendeles AS T1
JOIN tetel AS T2
ON T1.rendeles_id=T2.rendeles_id
AND (T2.kuldes_id IS NULL
OR T2.szamla_id IS NULL);

Distinctet csak azért tettem bele, hogy a több hiányos tétellel rendelkező rendelések csak egyszer szerepeljenek a listában, anélkül annyiszor kapnád vissza az azonosítóját, ahány tétele rossz.

Így csak egyszer fog végigmenni a táblákon *, majd az eredmény sorbarendezése után kihagyja a duplikációkat.

* vagy azon se, ha a tetel tablan van egy összetett index a rendeles_id, szamla_id, kuldes_id trióra.

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

Sokadik olvasatra sikerült megfejtenem, mit is akart jelenteni ez a sor:
AND rendeles_id NOT IN (SELECT IFNULL(rendeles_tmp,0) FROM user)

Ha jól értem, amíg a felhasználó nyitott egy tranzakciót, akkor az user tábla rendeles_tmp oszlopba íródik be a félkész rendelés ID-je, és ott is marad, amíg be nem fejezi a vásárlást.
(Remélem egy másik "trigger" takarítja a szemetet utána!
Bár én azt nem triggerre bíznám, hanem explicite kiadnám a delete-et a program kódban.
Ha ilyenekre triggereket használtok, ott valami nagyon félrement az alkalmazás tervezésekor/implementálásakor.)

Ekkor viszont a querym végére ezt egy WHERE-be kéne írni:
SELECT DISTINCT T1.rendeles_id
FROM rendeles AS T1
JOIN tetel AS T2
ON T1.rendeles_id=T2.rendeles_id
AND (T2.kuldes_id IS NULL
OR T2.szamla_id IS NULL)
WHERE T1.rendeles_id NOT IN (SELECT rendeles_tmp FROM user);

IFNULL(rendeles_tmp,0): ezt meg eleve nem értem, miért kell a null értékeket nullára konvertálni?
Ki nem töltött érték/null az nem része a halmaznak (IN), de az ellenkezőjének sem (NOT IN).

(Java programozóink szoktak vért izzadni, mert a DBben a null is értelmes érték.
Azt jelenti, hogy nincs adat. )

[ Szerkesztve ]

Hello IT! Have you tried turning it off and on again?

Igen jól érted másik trigger amint lezárja takarít.
A rendelés és a szamla id nem NULL hanem 0 ahol nincs megadva neki érték. Ezért kellett a min(rendeles_id) bele.

http://sb-soft.hu - "A" számlázó