Wat is het verschil tussen afknotten en verwijderen in SQL

Wat is het verschil tussen truncateEN deleteIN SQL?

Als uw antwoord specifiek is, geef dan aan dat.


1, Autoriteit 100%

Hier is een lijst met verschillen. Ik heb Oracle-specifieke functies gemarkeerd en hopelijk kan de gemeenschap ook een specifiek verschil van andere leveranciers toevoegen. Verschillen die de meeste verkopers gemeen hebben, kunnen direct onder de koppen gaan, met hieronder gemarkeerde verschillen.


Algemeen Overzicht

Als u snel alle rijen van een tabel wilt verwijderen, en u bent er echt zeker van dat u het wilt doen, en u hebt geen buitenlandse sleutels tegen de tafels, dan zal een afkappen waarschijnlijk sneller worden dan een verwijdering.

Verschillende systeemspecifieke kwesties moeten worden overwogen, zoals hieronder beschreven.


Verklaringstype

Delete is DML, TRURCATE is DDL (Wat is DDL en DML? )


commit en rollback

Variabele per leverancier

SQL * Server

afkappen kan worden teruggerold.

PostGresql

afkappen kan worden teruggerold.

orakel

Omdat een afkappen DDL is, omvat het twee commits, één voor en een na de uitvoering van het verklaring. Afkappen kan daarom niet worden teruggedraaid en een falen in het afkoppelingsproces heeft toch een commit uitgegeven.

Zie echter onderstaande flashback.


Space Reclamation

Delete herstelt geen ruimte, afkappen herstelt ruimte

orakel

Als u de REUSE STORAGE-clausule gebruikt, worden de gegevenssegmenten niet ongedaan gemaakt, wat iets efficiënter kan zijn als de tabel opnieuw moet worden geladen met gegevens. De hoogwatermarkering is gereset.


Rijbereik

Verwijderen kan worden gebruikt om alle rijen of alleen een subset van rijen te verwijderen. Truncate verwijdert alle rijen.

Oracle

Als een tabel is gepartitioneerd, kunnen de afzonderlijke partities afzonderlijk worden afgekapt, waardoor een gedeeltelijke verwijdering van alle tabelgegevens mogelijk is.


Objecttypen

Verwijderen kan worden toegepast op tabellen en tabellen binnen een cluster. Truncate is alleen van toepassing op tabellen of het hele cluster. (Kan Oracle-specifiek zijn)


Identiteit gegevensobject

Oracle

Verwijderen heeft geen invloed op de data-object-ID, maar truncate wijst een nieuwe data-object-ID toe tenzijer nooit een invoeging tegen de tabel is geweest sinds de creatie. Zelfs een enkele invoeging die wordt teruggedraaid, veroorzaakt een nieuw gegevensobject-ID dat moet worden toegewezen bij het inkorten.


Flashback (Oracle)

Flashback werkt over verwijderingen heen, maar een truncate voorkomt flashback naar toestanden voorafgaand aan de bewerking.

Vanaf 11gR2 staat de FLASHBACK ARCHIVE-functie dit echter toe, behalve in de Express-editie

Gebruik van FLASHBACK in Oracle
http://docs.oracle.com/cd/E11882_01 /appdev.112/e41502/adfns_flashback.htm#ADFNS638


Voorrechten

Variabele

Oracle

Verwijderen kan op een tafel worden verleend aan een andere gebruiker of rol, maar afkappen kan niet zonder gebruik te maken van een DROP ANY TABLE-toekenning.


Opnieuw/Ongedaan maken

Verwijderen genereert een kleine hoeveelheid opnieuw uitvoeren en een grote hoeveelheid ongedaan maken. Truncate genereert een verwaarloosbare hoeveelheid van elk.


Indexen

Oracle

Een truncate-bewerking maakt onbruikbare indexen weer bruikbaar. Verwijderen niet.


Buitenlandse sleutels

Een truncate kan niet worden toegepast wanneer een ingeschakelde refererende sleutel naar de tabel verwijst. Behandeling met verwijderen hangt af van de configuratie van de externe sleutels.


Tafelvergrendeling

Oracle

Truncate vereist een exclusieve tafelvergrendeling, voor verwijderen is een gedeelde tafelvergrendeling vereist. Daarom is het uitschakelen van tafelvergrendelingen een manier om afkapbewerkingen op een tafel te voorkomen.


Triggers

DML-triggers worden niet geactiveerd bij een truncate.

Oracle

DDL-triggers zijn beschikbaar.


Externe uitvoering

Oracle

Truncate kan niet worden uitgegeven via een databaselink.


Identiteitskolommen

SQL*Server

Truncate reset de volgorde voor IDENTITY-kolomtypen, verwijderen niet.


Resultatenset

In de meeste implementaties kan een delete-instructie de verwijderde rijen teruggeven aan de client.

bijv. in een Oracle PL/SQL-subprogramma kunt u:

DELETE FROM employees_temp
WHERE       employee_id = 299 
RETURNING   first_name,
            last_name
INTO        emp_first_name,
            emp_last_name;

Antwoord 2, autoriteit 72%

Het verschil tussen afkappen en verwijderen staat hieronder:

+----------------------------------------+----------------------------------------------+
|                Truncate                |                    Delete                    |
+----------------------------------------+----------------------------------------------+
| We can't Rollback after performing     | We can Rollback after delete.                |
| Truncate.                              |                                              |
|                                        |                                              |
| Example:                               | Example:                                     |
| BEGIN TRAN                             | BEGIN TRAN                                   |
| TRUNCATE TABLE tranTest                | DELETE FROM tranTest                         |
| SELECT * FROM tranTest                 | SELECT * FROM tranTest                       |
| ROLLBACK                               | ROLLBACK                                     |
| SELECT * FROM tranTest                 | SELECT * FROM tranTest                       |
+----------------------------------------+----------------------------------------------+
| Truncate reset identity of table.      | Delete does not reset identity of table.     |
+----------------------------------------+----------------------------------------------+
| It locks the entire table.             | It locks the table row.                      |
+----------------------------------------+----------------------------------------------+
| Its DDL(Data Definition Language)      | Its DML(Data Manipulation Language)          |
| command.                               | command.                                     |
+----------------------------------------+----------------------------------------------+
| We can't use WHERE clause with it.     | We can use WHERE to filter data to delete.   |
+----------------------------------------+----------------------------------------------+
| Trigger is not fired while truncate.   | Trigger is fired.                            |
+----------------------------------------+----------------------------------------------+
| Syntax :                               | Syntax :                                     |
| 1) TRUNCATE TABLE table_name           | 1) DELETE FROM table_name                    |
|                                        | 2) DELETE FROM table_name WHERE              |
|                                        |    example_column_id IN (1,2,3)              |
+----------------------------------------+----------------------------------------------+

Antwoord 3, autoriteit 22%

LATEN

Het DROP-commando verwijdert een tabel uit de database. Alle rijen, indexen en privileges van de tabellen worden ook verwijderd. Er worden geen DML-triggers geactiveerd. De bewerking kan niet worden teruggedraaid.

AFKNOP

TRUNCATE verwijdert alle rijen uit een tabel. De bewerking kan niet worden teruggedraaid en er worden geen triggers geactiveerd. Als zodanig is TRUNCATE sneller en gebruikt het niet zoveel ongedaanmakingsruimte als een DELETE. Vergrendeling op tafelniveau wordt toegevoegd bij afkappen.

VERWIJDEREN

Het DELETE-commando wordt gebruikt om rijen uit een tabel te verwijderen. Een WHERE-component kan worden gebruikt om slechts enkele rijen te verwijderen. Als er geen WHERE-voorwaarde is opgegeven, worden alle rijen verwijderd. Na het uitvoeren van een DELETE-bewerking moet u de transactie COMMIT of ROLLBACK uitvoeren om de wijziging permanent te maken of ongedaan te maken. Houd er rekening mee dat deze bewerking ervoor zorgt dat alle DELETE-triggers op de tafel worden geactiveerd. Rijniveauvergrendeling wordt toegevoegd bij het verwijderen.

Van: http://www.orafaq.com/faq/difference_between_truncate_delete_and_drop_commands


Antwoord 4, autoriteit 8%

Allemaal goede antwoorden, waaraan ik moet toevoegen:

Aangezien TRUNCATE TABLEeen DDL is (Data Defination Language) , geen DML (Data Manipulation Langauge) commando, de Delete Triggersniet rennen.


Antwoord 5, autoriteit 7%

Samenvatting van verwijderen versus afkappen in SQL-server
Volg deze link voor het volledige artikel: http://codaffection .com/sql-server-article/delete-vs-truncate-in-sql-server/

Genomen uit dotnet mob-artikel:Delete vs Truncate in SQL Server


Antwoord 6, autoriteit 7%

Met SQL Server of MySQL, als er een PK is met automatische verhoging, zal truncate de teller resetten.


Antwoord 7, autoriteit 5%

AFKNOP

TRUNCATE SQL-query verwijdert alle rijen uit een tabel, zonder dat de afzonderlijke rijverwijderingen worden geregistreerd.

  • TRUNCATE is een DDL-commando.
  • TRUNCATE wordt uitgevoerd met een tafelvergrendeling en de hele tafel is vergrendeld voor
    verwijder alle records.
  • We kunnen de WHERE-clausule niet gebruiken met TRUNCATE.
  • TRUNCATE verwijdert alle rijen uit een tabel.
  • Minimaal inloggen in transactielogboek, dus sneller qua prestaties.
  • TRUNCATE TABLE verwijdert de gegevens door de toewijzing van de gebruikte gegevenspagina’s ongedaan te maken
    om de tabelgegevens op te slaan en alleen de paginadeallocaties vast te leggen in
    het transactielogboek.
  • Om Truncate op een tafel te gebruiken, heb je ten minste ALTER-toestemming nodig op de
    tafel.
  • Truncate gebruikt minder transactieruimte dan het Delete-statement.
  • Truncate kan niet worden gebruikt met geïndexeerde weergaven.
  • TRUNCATE is sneller dan DELETE.

VERWIJDEREN

Om een DELETE-wachtrij uit te voeren, zijn verwijderrechten vereist op de doeltabel. Als u een WHERE-component in een DELETE moet gebruiken, zijn ook bepaalde machtigingen vereist.

  • DELETE is een DML-opdracht.
  • VERWIJDEREN wordt uitgevoerd met een rijvergrendeling, elke rij in de tabel is vergrendeld
    voor verwijdering.
  • We kunnen de where-clausule met DELETE gebruiken om & specifiek verwijderen
    records.
  • De opdracht DELETE wordt gebruikt om rijen uit een tabel te verwijderen op basis van WHERE
    staat.
  • Het houdt het logboek bij, dus het is langzamer dan TRUNCATE.
  • De DELETE-instructie verwijdert rijen één voor één en neemt een invoer op
    in het transactielogboek voor elke verwijderde rij.
  • Identiteit van kolom behouden DELETE behoudt de identiteit.
  • Als je Delete wilt gebruiken, heb je DELETE-rechten op de tafel nodig.
  • Verwijderen gebruikt meer transactieruimte dan Truncate-statement.
  • Verwijderen kan worden gebruikt met geïndexeerde weergaven.

Antwoord 8, autoriteit 4%

“Truncate logt niets” is correct. Ik zou verder gaan:

Truncate wordt niet uitgevoerd in de context van een transactie.

Het snelheidsvoordeel van afkappen ten opzichte van verwijderen zou duidelijk moeten zijn. Dat voordeel varieert van triviaal tot enorm, afhankelijk van uw situatie.

Ik heb echter een afkappen van onbedoeld referentiële integriteit gezien en overtreden andere beperkingen. De kracht die u wint door gegevens buiten een transactie te wijzigen, moet in evenwicht zijn tegen de verantwoordelijkheid die u erven wanneer u zonder een net naar het koord loopt.


9, Autoriteit 3%

Ja, Delete is langzamer, afkappen is sneller. Waarom?

DELETE moet de records lezen, beperkingen controleren, het blok bijwerken, indexen bijwerken en opnieuw uitvoeren/ongedaan maken genereren. Dat kost allemaal tijd.

TRUNCATE past eenvoudig een aanwijzer in de database aan voor de tafel (het High Water Mark) en poef! de gegevens zijn weg.

Dit is Oracle-specifiek, AFAIK.


Antwoord 10, autoriteit 2%

Als u per ongeluk alle gegevens uit de tabel hebt verwijderd met Delete/Truncate. U kunt vastgelegde transacties terugdraaien. Herstel de laatste back-up en voer het transactielogboek uit tot het moment waarop Verwijderen/Truncate op het punt staat te gebeuren.

De gerelateerde informatie hieronder is afkomstig van een blogpost:

Terwijl we aan de database werken, gebruiken we Delete en Truncate zonder
de verschillen ertussen kennen. In dit artikel bespreken we
het verschil tussen Delete en Truncate in Sql.

Verwijderen:

  • Verwijderen is een DML-opdracht.
  • Delete-instructie wordt uitgevoerd met een rijvergrendeling, elke rij in de tabel is vergrendeld voor verwijdering.
  • We kunnen filters specificeren in de where-clausule.
  • Het verwijdert gespecificeerde gegevens als er sprake is van een voorwaarde.
  • Activiteiten verwijderen een trigger omdat de bewerking afzonderlijk wordt vastgelegd.
  • Langzamer dan Truncate omdat het logs bijhoudt

Inkorten

  • Truncate is een DDL-commando.
  • Truncatietabel vergrendel altijd de tabel en pagina, maar niet elke rij. Omdat alle gegevens worden verwijderd.
  • Kan de Where-voorwaarde niet gebruiken.
  • Het verwijdert alle gegevens.
  • Truncate-tabel kan geen trigger activeren omdat de bewerking geen afzonderlijke rijverwijderingen registreert.
  • Sneller qua prestaties, omdat het geen logboeken bijhoudt.

Opmerking: Verwijderen en Afkappen kunnen beide worden teruggedraaid bij gebruik met
Transactie. Als de transactie is voltooid, betekent toegewijd, dan kunnen we dat niet
rollback Truncate-opdracht, maar we kunnen nog steeds de opdracht Verwijderen terugdraaien
uit logbestanden, zoals verwijderen schrijven registreert ze in logbestand voor het geval dat:
nodig om in de toekomst terug te draaien vanuit logbestanden.

Als u een beperking voor een externe sleutel heeft die verwijst naar de tabel die u bent
proberen af te kappen, dit zal niet werken, zelfs als de verwijzende tabel geen heeft
gegevens erin. Dit komt omdat de externe sleutelcontrole wordt gedaan met DDL
in plaats van DML. Dit kan worden omzeild door tijdelijk de
externe sleutelbeperking(en) naar de tabel.

Tabel verwijderen is een gelogde bewerking. Dus het verwijderen van elke rij krijgt
ingelogd in het transactielogboek, wat het traag maakt. Tabel afkappen
verwijdert ook alle rijen in een tabel, maar registreert niet de verwijdering van
elke rij registreert in plaats daarvan de deallocatie van de gegevenspagina’s van de
tabel, waardoor het sneller gaat.

~ Als u per ongeluk alle gegevens uit de tabel hebt verwijderd met
Verwijderen/afkappen. U kunt vastgelegde transacties terugdraaien. Herstel de
laatste back-up en transactielogboek uitvoeren tot het moment waarop Verwijderen/Truncate
staat op het punt te gebeuren.


Antwoord 11, autoriteit 2%

Hier is mijn gedetailleerde antwoord op het verschil tussen DELETE en TRUNCATE in SQL Server

Gegevens verwijderen: Allereerst kunnen beide worden gebruikt om de rijen uit de tabel te verwijderen.
Maar een DELETE kan worden gebruikt om de rijen niet alleen uit een tabel te verwijderen, maar ook uit een VIEW of het resultaat van een OPENROWSET of OPENQUERY, afhankelijk van de mogelijkheden van de provider.

FROM-clausule: Met DELETE kunt u ook rijen uit de ene tabel/view/rowset_function_limited verwijderen op basis van rijen uit een andere tabel door een andere FROM-clausule te gebruiken. In die FROM-clausule kun je ook normale JOIN-voorwaarden schrijven. U kunt eigenlijk een DELETE-instructie maken van een SELECT-instructie die geen statistische functies bevat door SELECT te vervangen door DELETE en kolomnamen te verwijderen.
Met TRUNCATE kun je dat niet doen.

WHERE: EEN TRUNCATE kan geen WHERE-voorwaarden hebben, maar een DELETE wel. Dat betekent dat u met TRUNCATE geen specifieke rij of specifieke groep rijen kunt verwijderen.
TRUNCATE TABLE is vergelijkbaar met de DELETE-instructie zonder WHERE-clausule.

Prestaties: TRUNCATE TABLE is sneller en gebruikt minder systeem- en transactielogboekbronnen.
En een van de redenen zijn sloten die door beide verklaringen worden gebruikt. De DELETE-instructie wordt uitgevoerd met behulp van een rijvergrendeling, elke rij in de tabel is vergrendeld voor verwijdering. TRUNCATE TABLE vergrendelt altijd de tabel en pagina, maar niet elke rij.

Transactielogboek: DELETE-instructie verwijdert rijen één voor één en maakt voor elke rij afzonderlijke vermeldingen in het transactielogboek.
TRUNCATE TABLE verwijdert de gegevens door de toewijzing van de gegevenspagina’s die worden gebruikt om de tabelgegevens op te slaan ongedaan te maken en registreert alleen de paginadeallocaties in het transactielogboek.

Pagina’s: Nadat een DELETE-instructie is uitgevoerd, kan de tabel nog steeds lege pagina’s bevatten.
TRUNCATE verwijdert de gegevens door de toewijzing van de gegevenspagina’s die worden gebruikt om de tabelgegevens op te slaan ongedaan te maken.

Trigger: TRUNCATE activeert de verwijdertriggers op de tafel niet. U moet dus heel voorzichtig zijn bij het gebruik van TRUNCATE. Men zou nooit een TRUNCATE moeten gebruiken als verwijdertrigger is gedefinieerd in de tabel om een automatische opschoning of logboekactie uit te voeren wanneer rijen worden verwijderd.

Identiteitskolom: Met TRUNCATE als de tabel een identiteitskolom bevat, wordt de teller voor die kolom teruggezet op de beginwaarde die voor de kolom is gedefinieerd. Als er geen seed is gedefinieerd, wordt de standaardwaarde 1 gebruikt.
DELETE reset de identiteitsteller niet. Dus als je de identiteitsteller wilt behouden, gebruik dan DELETE.

Replicatie: DELETE kan worden gebruikt tegen tabellen die worden gebruikt in transactionele replicatie of samenvoegreplicatie.
Hoewel TRUNCATE niet kan worden gebruikt voor de tabellen die betrokken zijn bij transactionele replicatie of samenvoegreplicatie.

Terugdraaien: DELETE-instructie kan worden teruggedraaid.
TRUNCATE kan ook worden teruggedraaid, op voorwaarde dat het is ingesloten in een TRANSACTIE-blok en de sessie niet is gesloten. Zodra de sessie is gesloten, kunt u TRUNCATE niet meer terugdraaien.

Beperkingen: de DELETE-instructie kan mislukken als deze een trigger schendt of probeert een rij te verwijderen waarnaar wordt verwezen door gegevens in een andere tabel met een FOREIGN KEY-beperking. Als met DELETE meerdere rijen worden verwijderd en een van de verwijderde rijen een trigger of beperking schendt, wordt de instructie geannuleerd, wordt een fout geretourneerd en worden er geen rijen verwijderd.
En als VERWIJDEREN wordt gebruikt tegen weergave, moet die weergave een bijwerkbare weergave zijn.
TRUNCATE kan niet worden gebruikt voor de tabel die wordt gebruikt in de geïndexeerde weergave.
TRUNCATE kan niet worden gebruikt voor de tabel waarnaar wordt verwezen door een FOREIGN KEY-beperking, tenzij een tabel een externe sleutel heeft die naar zichzelf verwijst.


Antwoord 12

In SQL Server 2005 geloof ik dat je kunteen truncate terugdraaien


Antwoord 13

VERWIJDEREN

Het DELETE-commando wordt gebruikt om rijen uit een tabel te verwijderen. Een WHERE-component kan worden gebruikt om slechts enkele rijen te verwijderen. Als er geen WHERE-voorwaarde is opgegeven, worden alle rijen verwijderd. Na het uitvoeren van een DELETE-bewerking moet u de transactie COMMIT of ROLLBACK uitvoeren om de wijziging permanent te maken of ongedaan te maken. Houd er rekening mee dat deze bewerking ervoor zorgt dat alle DELETE-triggers op de tafel worden geactiveerd.

AFKNOP

TRUNCATE verwijdert alle rijen uit een tabel. De bewerking kan niet worden teruggedraaid en er worden geen triggers geactiveerd. Als zodanig is TRUCATE sneller en gebruikt het niet zoveel ruimte voor ongedaan maken als een VERWIJDEREN.

LATEN

Het DROP-commando verwijdert een tabel uit de database. Alle rijen, indexen en privileges van de tabellen worden ook verwijderd. Er worden geen DML-triggers geactiveerd. De bewerking kan niet worden teruggedraaid.


DROP en TRUNCATE zijn DDL-commando’s, terwijl DELETE een DML-commando is. Daarom kunnen DELETE-bewerkingen worden teruggedraaid (ongedaan gemaakt), terwijl DROP- en TRUNCATE-bewerkingen niet kunnen worden teruggedraaid.

Van: http://www.orafaq.com/faq/difference_between_truncate_delete_and_drop_commands


Antwoord 14

TRUNCATE kan worden teruggedraaid als het in een transactie is verpakt.

Bekijk de twee referenties hieronder en test jezelf:-

http://blog.sqlauthority.com/2007/12/26/sql-server-truncate-cant-be-rolled-back-using-log-files-after-transaction -session-is-closed/

http://sqlblog.com/blogs/kalen_delaney/archive/2010/10/12/tsql-tuesday-11-rolling-back-truncate-table.aspx

De TRUNCATE vs. DELETE is een van de beruchte vragen tijdens SQL-interviews. Zorg ervoor dat je het goed uitlegt aan de interviewer, anders kost het je misschien de baan. Het probleem is dat niet veel mensen het weten, dus hoogstwaarschijnlijk zullen ze het antwoord als fout beschouwen als je ze vertelt dat JA Truncate kan worden teruggedraaid.


Antwoord 15

Een kleine correctie op het oorspronkelijke antwoord – verwijderen genereert ook aanzienlijke hoeveelheden opnieuw uitvoeren (omdat ongedaan maken zelf wordt beschermd door opnieuw). Dit is te zien aan de autotrace-uitvoer:

SQL> delete from t1;
10918 rows deleted.
Elapsed: 00:00:00.58
Execution Plan
----------------------------------------------------------
   0      DELETE STATEMENT Optimizer=FIRST_ROWS (Cost=43 Card=1)
   1    0   DELETE OF 'T1'
   2    1     TABLE ACCESS (FULL) OF 'T1' (TABLE) (Cost=43 Card=1)
Statistics
----------------------------------------------------------
         30  recursive calls
      12118  db block gets
        213  consistent gets
        142  physical reads
    3975328  redo size
        441  bytes sent via SQL*Net to client
        537  bytes received via SQL*Net from client
          4  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
      10918  rows processed

Antwoord 16

Een ander verschil tussen de twee bewerkingen is dat als de tabel een identiteitskolom bevat, de teller voor die kolom wordt teruggezet op 1 (of op de beginwaarde die voor de kolom is gedefinieerd) onder TRUNCATE. VERWIJDEREN heeft dit effect niet.


Antwoord 17

Het grootste verschil is dat afkappen een niet-gelogde bewerking is, terwijl verwijderen dat wel is.

Het betekent eenvoudigweg dat in het geval van een databasecrash, u de gegevens die met truncate zijn uitgevoerd niet kunt herstellen, maar met verwijderen wel.

Meer details hier


Antwoord 18

DELETE-instructie: met deze opdracht worden alleen de rijen uit de tabel verwijderd op basis van de voorwaarde die wordt gegeven in de where-clausule of worden alle rijen uit de tabel verwijderd als er geen voorwaarde is opgegeven. Maar het maakt de ruimte met de tabel niet vrij.

De syntaxis van een SQL DELETE-instructie is:

VERWIJDEREN UIT tabelnaam [WAAR voorwaarde];

TRUNCATE-instructie: deze opdracht wordt gebruikt om alle rijen uit de tabel te verwijderen en de ruimte met de tabel vrij te maken.


Antwoord 19

VERWIJDEREN

DELETE is a DML command
DELETE you can rollback
Delete = Only Delete- so it can be rolled back
In DELETE you can write conditions using WHERE clause
Syntax – Delete from [Table] where [Condition]

AFKNOP

TRUNCATE is a DDL command
You can't rollback in TRUNCATE, TRUNCATE removes the record permanently
Truncate = Delete+Commit -so we can't roll back
You can't use conditions(WHERE clause) in TRUNCATE
Syntax – Truncate table [Table]

Ga voor meer informatie naar

http://www.zilckh.com /wat-is-het-verschil-tussen-afkappen-en-verwijderen/


Antwoord 20

Kortom, truncate logt niets (dus is veel sneller maar kan niet ongedaan worden gemaakt), terwijl verwijderen wordt gelogd (en deel kan uitmaken van een grotere transactie, zal worden teruggedraaid, enz.). Als u gegevens heeft die u niet in een tabel in dev wilt hebben, is het normaal gesproken beter om deze af te kappen, omdat u niet het risico loopt het transactielogboek vol te lopen


Antwoord 21

Een belangrijke reden waarom het handig is, is wanneer u de gegevens in een tabel met miljoenen rijen moet vernieuwen, maar deze niet opnieuw wilt opbouwen. “Verwijderen *” zou een eeuwigheid duren, terwijl de prestatie-impact van Truncate verwaarloosbaar zou zijn.


Antwoord 22

Kan geen DDL uitvoeren via een dblink.


Antwoord 23

Ik zou reageren op het bericht van Matthieu, maar ik heb de vertegenwoordiger nog niet…

In MySQL wordt de automatische ophogingsteller gereset met afkappen, maar niet met verwijderen.


Antwoord 24

Het is niet zo dat truncate niets registreert in SQL Server. truncate registreert geen informatie, maar het registreert de deallocation of data-pagina voor de tabel waarop u TRUNCATE hebt geactiveerd.

en afgekapte record kunnen worden teruggedraaid als we transactie aan het begin definiëren en we kunnen de afgekapte record herstellen nadat deze is teruggedraaid. Maar kan afgekapte records niet herstellen uit de back-up van het transactielogboek na een vastgelegde afgekapte transactie.


Antwoord 25

Truncate kan hier ook worden teruggedraaid, het voorbeeld

begin Tran
delete from  Employee
select * from Employee
Rollback
select * from Employee

Antwoord 26

Truncate en Delete in SQL zijn twee commando’s die worden gebruikt om gegevens uit een tabel te verwijderen of te verwijderen. Hoewel ze vrij eenvoudig van aard zijn, kunnen beide Sql-opdrachten veel problemen veroorzaken totdat u bekend bent met de details voordat u ze gebruikt.
Een onjuiste keuze van het commando kan resulteren in een zeer traag proces of kan zelfs het log-segment opblazen, als er te veel gegevens moeten worden verwijderd en het log-segment niet genoeg is. Daarom is het van cruciaal belang om te weten wanneer u de opdracht truncate en delete in SQL moet gebruiken, maar voordat u deze gebruikt, moet u zich bewust zijn van de verschillen tussen Truncate en Delete, en op basis daarvan zouden we moeten kunnen achterhalen wanneer DELETE een betere optie is om te verwijderen data of TRUNCATE moet worden gebruikt om tabellen op te schonen.

Zie check klik hier


Antwoord 27

Door een TRUNCATE TABLE-instructie uit te geven, geeft u SQL Server de opdracht om elk record in een tabel te verwijderen, zonder dat er logboekregistratie of transactieverwerking plaatsvindt.


Antwoord 28

DELETE-instructie kan een WHERE-clausule hebben om specifieke records te verwijderen, terwijl TRUNCATE-instructie geen enkele vereist en de hele tabel wist.
Belangrijk is dat de DELETE-instructie de verwijderde datum registreert, terwijl de TRUNCATE-instructie dat niet doet.


Antwoord 29

Nog een specifiek verschil voor microsoft sql-server is dat u met deletede instructie outputkunt gebruiken om bij te houden welke records zijn verwijderd, bijvoorbeeld:

delete from [SomeTable]
output deleted.Id, deleted.Name

Je kunt dit niet doen met truncate.

Other episodes