Jag ska köra en update på en tabell som sätter in mellanslag före dom posterna som har mindre än fem tecken. Detta är redan fixat. Men när jag kör denna uppkommer det ett antal dubletter. Jag vet inte vilka och hur många det är.

Men om man kan köra ovanstående på en post kasta in svaret i en temporär post och jämför detta med alla andra. Sen loopar man sig ner genom tabellen. Det borde fungera (om man kan koden..)

Vill du alltså ta bort alla rader där värdet i en viss kolumn är en dublett av värdet i samma kolumn på någon annan rad? Isf är här ett exempel som du kan använda om du har en numerisk nyckel:

<code>
DELETE FROM foo
WHERE keycolumn IN (
SELECT keycolumn
FROM foo x
WHERE keycolumn > (SELECT MIN(keycolumn) FROM foo WHERE duplicatecolumn = x.duplicatecolumn)
)
</code>

Så här plockar du ut dubletterna och hur många dubletter det är:
SELECT KolumnNamn, Count(*) As Antal
FROM TabellNamn
GROUP BY KolumnNamn
HAVING Count(*) > 1

Om jag kör nedanstående kod på några rader tex:
_xxxx (_ är lika med mellanslag)
xxxx

skapas det dubletter (xxxx blir _xxxx)

Jag vill ta reda på vilka dubbletterna blir. Om man kan spoola ut resultatet till en txtfil är det önskvärt.

kod start
--------------------------------------------------------------------------------------------------
update pr_symbs
set typ = lpad(substr(typ,1,instr(typ,'.',1)),6) || substr(typ,instr(typ,'.',1)+1)
where length(substr(typ,1,instr(typ,'.',1))) < 6 and typ like '%.%'
/

update pr_symbs
set a = lpad(a,5)
where length(a) < 5 and a not like '%.%' and a not like '%,%'
/
--------------------------------------------------------------------------------------------------
kod slut

Andreas visade ju hur du tar reda på vilka dubletter det finns. Dock undrar jag, det måste ju ha funnits dubletter även innan du uppdaterar? Om XXXX blir _XXXX och det då finns flera _XXXX måste det ju ha funnits flera XXXX innan? Iofs, visst, det kan ha funnits en XXXX och en _XXXX och då får du ju förstås två _XXXX. Hur du spolar ut till textfil är jag inte helt säker på, antar att det är Oracle du använder. Men du kan väl iaf bara helt enkelt köra en fråga enligt Andreas modell i SQLPlus och helt enkelt pipa ut resultatet till en textfil?

Det är det senare exemplet som jag är ute efter

"Iofs, visst, det kan ha funnits en XXXX och en _XXXX och då får du ju förstås två _XXXX. "

Kör jag enligt andreas modell fungerar det på dubletter som redan finns men inte på "nästan"-dubletter. Testade och det fungerade inte.

SELECT u, Count(u) As Antal
FROM PR_symbs
where u like '%0554%'
GROUP BY u
HAVING Count(u) > 1

Kör jag denna får jag inte fram något..

Men om jag däremot kör

SELECT u, Count(u) As Antal
FROM PR_symbs
where u like '%0554%'
GROUP BY u
HAVING Count(u) = 1

Får jag fram två poster. En med mellanslag och en utan...

//Henrik

Så du menar att du vill ha en fråga som identifierar de dubbletter som kommer att
uppstå efter din update-sats? så att du kan åtgärda problemet innan det hinner
uppstå?

Du borde kunna lägga in en kontroll mha av inner join - och jämföra alla rader i
databasen med varandra och lägga till det fixa antal mellanslag din update skulle göra
till det nuvarande värdet i jämförelsen.

/Emma

SELECT LTRIM(u), Count(u) As Antal
FROM PR_symbs
where u like '%0554%'
GROUP BY LTRIM(u)
HAVING Count(u) > 1

Nu fungerar det.


SELECT LTRIM(u), Count(u) As Antal
FROM PR_symbs
where u like '%0554%'
GROUP BY LTRIM(u)
HAVING Count(u) > 1


Det är så enkelt när man kan det....

Tack för hjälpen Christoffer