pt-archiverp - Online nel cloud

PROGRAMMA:

NOME

pt-archiver - Archivia le righe da una tabella MySQL in un'altra tabella o file.

SINOSSI

Utilizzo: pt-archiver [OPZIONI] --source DSN --where WHERE

pt-archiver nibble record da una tabella MySQL. Gli argomenti --source e --dest usano DSN
sintassi; se COPY è sì, --dest viene impostato automaticamente sul valore della chiave da --source.

Consigli d'uso:

Archivia tutte le righe da oltp_server a olap_server e in un file:

pt-archiver --source h=oltp_server,D=test,t=tbl --dest h=olap_server \
--file '/var/log/archive/%Y-%m-%d-%D.%t' \
--dove "1=1" --limit 1000 --commit-each

Elimina (elimina) le righe orfane dalla tabella figlio:

pt-archiver --source h=host,D=db,t=figlio --purge \
--where 'NON ESISTE (SELECT * FROM parent WHERE col=child.col)'

RISCHI

Percona Toolkit è maturo, collaudato nel mondo reale e ben testato, ma tutto database
strumenti possono rappresentare un rischio per il sistema e il server del database. Prima di utilizzare questo strumento,
per favore:

· Leggi la documentazione dello strumento

· Rivedere i "BUG" noti dello strumento

· Testare lo strumento su un server non di produzione

· Eseguire il backup del server di produzione e verificare i backup

DESCRIZIONE

pt-archiver è lo strumento che uso per archiviare le tabelle come descritto in
<http://tinyurl.com/mysql-archiving>. L'obiettivo è un lavoro a basso impatto, solo in avanti per
sgranocchiare vecchi dati dalla tabella senza influire molto sulle query OLTP. Puoi inserire il
dati in un'altra tabella, che non deve essere necessariamente sullo stesso server. Puoi anche scriverlo ad a
file in un formato adatto a LOAD DATA INFILE. Oppure non puoi fare nessuna delle due, nel qual caso è
solo un DELETE incrementale.

pt-archiver è estensibile tramite un meccanismo di plugin. Puoi inserire il tuo codice da aggiungere
logica di archiviazione avanzata che potrebbe essere utile per l'archiviazione dei dati dipendenti, applicando
complesse regole aziendali o costruire un data warehouse durante il processo di archiviazione.

È necessario scegliere i valori con attenzione per alcune opzioni. I più importanti sono "--limit",
"--tentativi" e "--txn-size".

La strategia consiste nel trovare la prima riga (o le prime righe), quindi eseguire la scansione di alcuni indici solo in avanti per trovarne altri
righe in modo efficiente. Ogni query successiva non dovrebbe analizzare l'intera tabella; dovrebbe cercare
nell'indice, quindi scansiona finché non trova più righe archiviabili. Specificare l'indice con
la parte 'i' dell'argomento "--source" può essere cruciale per questo; usa "--funzionamento a secco" per
esamina le query generate e assicurati di SPIEGARLE per vedere se sono efficienti
(la maggior parte delle volte probabilmente vorrai scansionare la chiave PRIMARIA, che è l'impostazione predefinita). Persino
meglio, esaminare la differenza nei contatori di stato dell'Handler prima e dopo l'esecuzione del
query e assicurati che non esegua la scansione dell'intera tabella ad ogni query.

Puoi disabilitare le ottimizzazioni di ricerca e scansione parzialmente o interamente con "--no-ascend"
e "--ascende-first". A volte questo può essere più efficiente per le chiavi a più colonne. Essere
consapevole che pt-archiver è costruito per iniziare dall'inizio dell'indice che sceglie e scansiona
è solo in avanti. Ciò potrebbe comportare lunghe scansioni della tabella se stai cercando di sgranocchiare da
la fine della tabella da un indice diverso da quello che preferisce. Vedi "--source" e leggi
la documentazione sulla parte "i" se questo si applica a te.

percona XtraDB Cluster

pt-archiver funziona con Percona XtraDB Cluster (PXC) 5.5.28-23.7 e successivi, ma ci sono
tre limitazioni da considerare prima di archiviare su un cluster:

Errore durante il commit
pt-archiver non verifica la presenza di errori quando esegue il commit delle transazioni. Si impegna su PXC può
fallisce, ma lo strumento non verifica o riprova la transazione quando ciò accade.
Se succede, lo strumento morirà.

Tabelle MyISAM
L'archiviazione delle tabelle MyISAM funziona, ma il supporto MyISAM in PXC è ancora sperimentale al
momento di questo rilascio. Esistono diversi bug noti con PXC, tabelle MyISAM e
Colonne "AUTO_INCREMENT". Pertanto, è necessario assicurarsi che l'archiviazione non avvenga direttamente
o indirettamente comportano l'utilizzo di valori "AUTO_INCREMENT" predefiniti per una tabella MyISAM.
Ad esempio, questo accade con "--dest" se viene utilizzato "--columns" e il
La colonna "AUTO_INCREMENT" non è inclusa. Lo strumento non verifica questo!

Opzioni non cluster
Alcune opzioni possono o non possono funzionare. Ad esempio, se un nodo del cluster non è anche a
slave, allora "--check-slave-lag" non funziona. E poiché le tabelle PXC di solito sono
InnoDB, ma InnoDB non supporta "INSERT DELAYED", quindi "--delayed-insert" no
opera. Anche altre opzioni potrebbero non funzionare, ma lo strumento non le controlla, quindi
dovresti testare l'archiviazione su un cluster di prova prima di archiviare sul tuo vero cluster.

USCITA

Se si specifica "--progress", l'output è una riga di intestazione, più l'output di stato a intervalli.
Ogni riga nell'output di stato elenca la data e l'ora correnti, quanti secondi pt-
archiver è stato eseguito e quante righe ha archiviato.

Se specifichi "--statistics", "pt-archiver" restituisce i tempi e altre informazioni utili
identifichi quale parte del tuo processo di archiviazione richiede più tempo.

GESTIONE DEGLI ERRORI

pt-archiver cerca di catturare i segnali e di uscire con grazia; per esempio, se lo spedisci
SIGTERM (Ctrl-C su sistemi UNIX), catturerà il segnale, stamperà un messaggio sul
segnale e uscire abbastanza normalmente. Non eseguirà "--analyze" o "--optimize",
perché potrebbero volerci molto tempo per finire. Verrà eseguito tutto il resto del codice normalmente,
compresa la chiamata dopo_finitura() su eventuali plugin (vedi "ESTENSIONE").

In altre parole, un segnale, se catturato, uscirà dal ciclo di archiviazione principale e salterà
ottimizzare/analizzare.

VERSIONI

Specificare almeno uno tra "--dest", "--file" o "--purge".

"--ignore" e "--replace" si escludono a vicenda.

"--txn-size" e "--commit-each" si escludono a vicenda.

"--low-priority-insert" e "--delayed-insert" si escludono a vicenda.

"--share-lock" e "--for-update" si escludono a vicenda.

"--analyze" e "--optimize" si escludono a vicenda.

"--no-ascend" e "--no-delete" si escludono a vicenda.

I valori DSN in "--dest" sono predefiniti sui valori di "--source" se COPY è sì.

--analizzare
tipo: stringa

Eseguire ANALYZE TABLE in seguito su "--source" e/o "--dest".

Esegue ANALISI TABELLA dopo aver terminato. L'argomento è una stringa arbitraria. se è
contiene la lettera 's', verrà analizzata la fonte. Se contiene 'd', il
verrà analizzata la destinazione. Puoi specificare uno o entrambi. Ad esempio, il
di seguito analizzeranno entrambi:

--analyze=ds

Vederehttp://dev.mysql.com/doc/en/analyze-table.html> per i dettagli sulla TABELLA ANALISI.

--ascende-first
Ascende solo la prima colonna dell'indice.

Se vuoi usare l'ottimizzazione dell'indice ascendente (vedi "--no-ascend"), ma non farlo
vuoi sostenere il sovraccarico di salire un grande indice a più colonne, puoi usare questo
opzione per dire a pt-archiver di salire solo sulla colonna più a sinistra dell'indice. questo può
fornire un significativo aumento delle prestazioni rispetto a non salire affatto l'indice, mentre
evitando il costo di salire l'intero indice.

Vedi "ESTENDERE" per una discussione su come questo interagisce con i plugin.

--chiedi-passa
Richiedi una password durante la connessione a MySQL.

--respingente
Buffer l'output su "--file" e scarica al commit.

Disabilita il flush automatico su "--file" e scarica "--file" su disco solo quando una transazione
commette. Questo in genere significa che il file viene scaricato a blocchi dal sistema operativo, quindi
potrebbero esserci anche alcuni flush impliciti su disco tra i commit. L'impostazione predefinita è
svuota "--file" su disco dopo ogni riga.

Il pericolo è che un arresto anomalo possa causare la perdita di dati.

L'aumento delle prestazioni che ho riscontrato utilizzando "--buffer" è compreso tra il 5 e il 15% circa.
La tua situazione potrebbe essere diversa.

--elimina in blocco
Elimina ogni blocco con una singola istruzione (implica "--commit-each").

Elimina ogni blocco di righe in blocco con una singola istruzione "DELETE". La dichiarazione
elimina ogni riga tra la prima e l'ultima riga del blocco, inclusa. Implica
"--commit-each", poiché sarebbe una cattiva idea "INSERIRE" le righe una alla volta e
commetterli prima del bulk "DELETE".

Il metodo normale consiste nell'eliminare ogni riga tramite la sua chiave primaria. Le eliminazioni in blocco potrebbero essere un problema
molto più veloce. Essi anche forza non be più veloce se hai una clausola "WHERE" complessa.

Questa opzione rimanda completamente tutta l'elaborazione "DELETE" fino a quando il blocco di righe è
finito. Se hai un plugin sul sorgente, il suo metodo "before_delete" non sarà
chiamato. Invece, il suo metodo "before_bulk_delete" viene chiamato in seguito.

AVVERTIMENTO: se hai un plugin sul sorgente che a volte non restituisce true da
"is_archivable()", dovresti usare questa opzione solo se capisci cosa fa. Se
il plugin indica a "pt-archiver" di non archiviare una riga, verrà comunque eliminata da
l'eliminazione di massa!

--[no]limite di eliminazione di massa
predefinito: sì

Aggiungi "--limit" all'istruzione "--bulk-delete".

Questa è un'opzione avanzata e non dovresti disabilitarla a meno che tu non sappia cosa sei
fare e perché! Per impostazione predefinita, "--bulk-delete" aggiunge una clausola "--limit" al bulk
eliminare l'istruzione SQL. In alcuni casi, questa clausola può essere omessa specificando
"--no-bulk-delete-limit". "--limit" deve ancora essere specificato.

--inserto in blocco
Inserisci ogni pezzo con LOAD DATA INFILE (implica "--bulk-delete" "--commit-each").

Inserisci ogni blocco di righe con "LOAD DATA LOCAL INFILE". Questo potrebbe essere molto più veloce di
inserendo una riga alla volta con istruzioni "INSERT". Viene implementato creando a
file temporaneo per ogni blocco di righe e scrivendo le righe in questo file invece di
inserendole. Quando il pezzo è finito, carica le righe.

Per proteggere la sicurezza dei tuoi dati, questa opzione impone l'utilizzo delle eliminazioni in blocco. Esso
non sarebbe sicuro eliminare ogni riga così come viene trovata, prima di inserire le righe nel
destinazione prima. La forzatura delle eliminazioni in blocco garantisce che l'eliminazione attenda fino a quando
l'inserimento è andato a buon fine.

Le opzioni "--low-priority-insert", "--replace" e "--ignore" funzionano con questo
opzione, ma "--delayed-insert" no.

Se "LOAD DATA LOCAL INFILE" genera un errore nelle righe di "Il comando utilizzato non è
consentito con questa versione di MySQL", fare riferimento alla documentazione per l'opzione "L" DSN.

--set di caratteri
forma breve: -A; tipo: stringa

Set di caratteri predefinito. Se il valore è utf8, imposta il binmode di Perl su STDOUT su utf8,
passa l'opzione mysql_enable_utf8 a DBD::mysql ed esegue SET NAMES UTF8 dopo
connessione a MySQL. Qualsiasi altro valore imposta binmode su STDOUT senza il livello utf8,
ed esegue SET NAMES dopo la connessione a MySQL.

Nota che vengono riconosciuti solo i set di caratteri conosciuti da MySQL; Quindi, ad esempio, "UTF8" lo farà
funzionerà, ma "UTF-8" no.

Vedi anche "--[no]check-charset".

--[no]set di caratteri di controllo
predefinito: sì

Assicurarsi che i set di caratteri di connessione e tabella siano gli stessi. La disabilitazione di questo controllo potrebbe
causare la conversione errata del testo da un set di caratteri a un altro (di solito da
utf8 a latin1) che può causare la perdita di dati o mojibake. La disabilitazione di questo controllo potrebbe essere
utile o necessario quando sono previste conversioni di set di caratteri.

--[no]colonne di spunta
predefinito: sì

Assicurati che "--source" e "--dest" abbiano le stesse colonne.

Abilitato per impostazione predefinita; fa sì che pt-archiver controlli che le tabelle di origine e di destinazione
hanno le stesse colonne Non controlla l'ordine delle colonne, il tipo di dati, ecc
verifica che tutte le colonne dell'origine esistano nella destinazione e viceversa. Se
ci sono differenze, pt-archiver uscirà con un errore.

Per disabilitare questo controllo, specifica --no-check-columns.

--intervallo di controllo
tipo: ora; predefinito: 1s

Se viene fornito "--check-slave-lag", questo definisce per quanto tempo lo strumento si ferma ciascuno
volta scopre che uno schiavo è in ritardo.
Questo controllo viene eseguito ogni 100 righe.

--check-slave-lag
tipo: stringa; ripetibile: sì

Sospendi l'archiviazione finché il ritardo dello slave del DSN specificato è inferiore a "--max-lag". Questo
l'opzione può essere specificata più volte per controllare più di uno slave.

--colonne
forma breve: -c; tipo: array

Elenco separato da virgole di colonne da archiviare.

Specificare un elenco di colonne separate da virgole da recuperare, scrivere nel file e inserirle
la tabella di destinazione. Se specificato, pt-archiver ignora le altre colonne a meno che non lo sia
deve aggiungerli all'istruzione "SELECT" per aumentare un indice o eliminare righe.
Recupera e usa queste colonne extra internamente, ma non le scrive nel
file o alla tabella di destinazione. Esso effettua passarli ai plugin.

Vedi anche "--primary-key-only".

--commit-ogni
Conferma ogni set di righe recuperate e archiviate (disabilita "--txn-size").

Esegue il commit delle transazioni e scarica "--file" dopo che ogni set di righe è stato archiviato,
prima di recuperare la serie successiva di righe e prima di dormire se è specificato "--sleep".
Disabilita "--txn-size"; usa "--limit" per controllare la dimensione della transazione con
"--commetti-ciascuno".

Questa opzione è utile come scorciatoia per rendere "--limit" e "--txn-size" lo stesso valore,
ma soprattutto evita che le transazioni vengano tenute aperte durante la ricerca di altro
righe. Ad esempio, immagina di archiviare vecchie righe dall'inizio di un file molto
tavolo grande, con "--limit" 1000 e "--txn-size" 1000. Dopo un po' di tempo per trovare
e archiviando 1000 righe alla volta, pt-archiver trova le ultime 999 righe e archivi
loro, quindi esegue la successiva SELECT per trovare più righe. Questo scansiona il resto del
table, ma non trova più righe. Ha tenuto aperta una transazione per molto tempo
tempo, solo per determinare che è comunque finito. Puoi usare "--commit-each" per evitare
Questo.

--config
tipo: array

Leggi questo elenco separato da virgole di file di configurazione; se specificato, questo deve essere il primo
opzione sulla riga di comando.

--Banca dati
forma breve MrGreen ; tipo: stringa

Connettiti a questo database.

--inserimento-ritardato
Aggiungi il modificatore DELAYED alle istruzioni INSERT.

Aggiunge il modificatore DELAYED alle istruzioni INSERT o REPLACE. Vedere
<http://dev.mysql.com/doc/en/insert.html> per i dettagli.

--dest
tipo: DSN

DSN che specifica la tabella in cui archiviare.

Questo elemento specifica una tabella in cui pt-archiver inserirà le righe archiviate da
"--fonte". Utilizza lo stesso formato di argomento key=val di "--source". La maggior parte manca
i valori predefiniti sono gli stessi valori di "--source", quindi non devi ripetere le opzioni
che sono gli stessi in "--source" e "--dest". Usa l'opzione "--help" per vedere quale
i valori vengono copiati da "--source".

AVVERTIMENTO: Utilizzo di un'opzione DSN del file delle opzioni predefinite (F) che definisce un socket per
"--source" fa in modo che pt-archiver si connetta a "--dest" usando quel socket a meno che non sia un altro
socket per "--dest" è specificato. Ciò significa che pt-archiver potrebbe connettersi in modo errato
a "--source" quando si connette a "--dest". Per esempio:

--source F=host1.cnf,D=db,t=tbl --dest h=host2

Quando pt-archiver si connette a "--dest", host2, si connetterà tramite "--source",
host1, socket definito in host1.cnf.

--funzionamento a secco
Stampa le query ed esci senza fare nulla.

Fa sì che pt-archiver esca dopo aver stampato il nome del file e le istruzioni SQL che utilizzerà.

--file
tipo: stringa

File in cui archiviare, con FORMATO DATA()-come la formattazione.

Nome file in cui scrivere le righe archiviate. Un sottoinsieme di MySQL FORMATO DATA() formattazione
i codici sono consentiti nel nome del file, come segue:

%d Giorno del mese, numerico (01..31)
%H Ora (00..23)
%i Minuti, numerici (00..59)
%m mese, numerico (01..12)
%s Secondi (00..59)
%Y Anno, numerico, quattro cifre

Puoi utilizzare anche i seguenti codici formato extra:

%D Nome database
%t Nome tabella

Esempio:

--file '/var/log/archive/%Y-%m-%d-%D.%t'

Il contenuto del file è nello stesso formato utilizzato da SELECT INTO OUTFILE, come documentato
nel manuale di MySQL: righe terminate da newline, colonne terminate da tab, NULL
i caratteri sono rappresentati da \N e i caratteri speciali sono preceduti da \. Questo permette
si ricarica un file con le impostazioni predefinite di LOAD DATA INFILE.

Se vuoi un'intestazione di colonna nella parte superiore del file, vedi "--header". Il file è auto-
svuotato per impostazione predefinita; vedere "--buffer".

--per-aggiornare
Aggiunge il modificatore FOR UPDATE alle istruzioni SELECT.

Per i dettagli, vederehttp://dev.mysql.com/doc/en/innodb-locking-reads.html>.

--intestazione
Stampa l'intestazione della colonna in cima a "--file".

Scrive i nomi delle colonne come prima riga nel file fornito da "--file". Se il file
esiste, non scrive intestazioni; questo mantiene il file caricabile con LOAD DATA INFILE in
caso si aggiunge più output ad esso.

--Aiuto
Mostra aiuto ed esci.

--selezione ad alta priorità
Aggiunge il modificatore HIGH_PRIORITY alle istruzioni SELECT.

Vederehttp://dev.mysql.com/doc/en/select.html> per i dettagli.

--ospite
forma breve: -h; tipo: stringa

Connettiti all'host.

--ignorare
Usa IGNORE per le istruzioni INSERT.

Fa sì che INSERT in "--dest" sia INSERT IGNORE.

--limite
tipo: int; predefinito: 1

Numero di righe da recuperare e archiviare per istruzione.

Limita il numero di righe restituite dalle istruzioni SELECT che recuperano righe a
archivio. L'impostazione predefinita è una riga. Potrebbe essere più efficiente aumentare il limite, ma si
attenzione se stai archiviando in modo sparso, saltando molte righe; questo può potenzialmente
causare più contesa con altre query, a seconda del motore di archiviazione, transazione
livello di isolamento e opzioni come "--for-update".

--Locale
Non scrivere query OPTIMIZE o ANALYZE su binlog.

Aggiunge il modificatore NO_WRITE_TO_BINLOG alle query ANALYZE e OPTIMIZE. Vedere "--analizzare"
per i dettagli.

--eliminazione-bassa priorità
Aggiunge il modificatore LOW_PRIORITY alle istruzioni DELETE.

Vederehttp://dev.mysql.com/doc/en/delete.html> per i dettagli.

--inserimento-bassa priorità
Aggiunge il modificatore LOW_PRIORITY alle istruzioni INSERT o REPLACE.

Vederehttp://dev.mysql.com/doc/en/insert.html> per i dettagli.

--max-flusso-ctl
tipo: galleggiante

Un po' simile a --max-lag ma per i cluster PXC. Controlla il tempo medio speso in cluster
mettere in pausa per il controllo del flusso e mettere in pausa lo strumento se supera la percentuale indicata
nell'opzione. L'impostazione predefinita è nessun controllo del controllo di flusso. Questa opzione è disponibile per PXC
versioni 5.6 o successive.

--max-ritardo
tipo: ora; predefinito: 1s

Mette in pausa l'archiviazione se lo slave dato da "--check-slave-lag" è in ritardo.

Questa opzione fa sì che pt-archiver guardi lo slave ogni volta che sta per recuperare
un'altra riga. Se il ritardo dello slave è maggiore del valore dell'opzione, o se lo slave
non è in esecuzione (quindi il suo ritardo è NULL), pt-table-checksum dorme per "--check-interval"
secondi e poi guarda di nuovo il ritardo. Si ripete finché lo schiavo non viene raggiunto,
quindi procede a recuperare e archiviare la riga.

Questa opzione può eliminare la necessità di "--sleep" o "--sleep-coef".

--no-ascendere
Non utilizzare l'ottimizzazione dell'indice crescente.

L'ottimizzazione dell'indice ascendente predefinita fa sì che "pt-archiver" ottimizzi ripetute
Query "SELECT" in modo che cerchino nell'indice in cui è terminata la query precedente, quindi scansiona
lungo di esso, invece di scansionare ogni volta dall'inizio della tabella. Questo è
abilitato per impostazione predefinita perché è generalmente una buona strategia per gli accessi ripetuti.

Indici di grandi dimensioni a più colonne possono far sì che la clausola WHERE sia abbastanza complessa da
questo potrebbe effettivamente essere meno efficiente. Consideriamo ad esempio una CHIAVE PRIMARIA a quattro colonne
su (a, b, c, d). La clausola WHERE per iniziare dove è terminata l'ultima query è la seguente:

DOVE (a > ?)
OPPURE (a = ? E b > ?)
OPPURE (a = ? E b = ? E c > ?)
OPPURE (a = ? E b = ? E c = ? E d >= ?)

Il popolamento dei segnaposto con valori utilizza memoria e CPU, aggiunge traffico di rete e
l'analisi del sovraccarico e potrebbe rendere la query più difficile da ottimizzare per MySQL. A quattro colonne
la chiave non è un grosso problema, ma una chiave a dieci colonne in cui ogni colonna consente "NULL" potrebbe
essere.

L'aumento dell'indice potrebbe non essere necessario se sai che stai semplicemente rimuovendo le righe
dall'inizio del tavolo a pezzi, ma senza lasciare buchi, quindi a partire da
l'inizio della tabella è in realtà la cosa più efficiente da fare.

Vedi anche "--ascend-first". Vedi "ESTENDERE" per una discussione su come questo interagisce
con i plugin.

--no-cancella
Non eliminare le righe archiviate.

Fa sì che "pt-archiver" non elimini le righe dopo averle elaborate. Questo non consente
"--no-ascend", perché abilitarli entrambi causerebbe un ciclo infinito.

Se c'è un plugin sul DSN di origine, il suo metodo "before_delete" viene chiamato comunque,
anche se "pt-archiver" non eseguirà l'eliminazione. Vedere "ESTENDERE" per ulteriori informazioni
plugins.

--ottimizzare
tipo: stringa

Eseguire OPTIMIZE TABLE in seguito su "--source" e/o "--dest".

Esegue OTTIMIZZA TABELLA dopo aver terminato. Vedere "--analyze" per la sintassi dell'opzione e
<http://dev.mysql.com/doc/en/optimize-table.html> per i dettagli sulla TABELLA OTTIMIZZA.

--parola d'ordine
forma breve: -p; tipo: stringa

Password da utilizzare durante la connessione. Se la password contiene virgole, devono essere sfuggite
con una barra rovesciata: "esame\,ple"

--pid
tipo: stringa

Crea il file PID specificato. Lo strumento non si avvia se il file PID esiste già e
il PID che contiene è diverso dal PID corrente. Tuttavia, se il file PID
esiste e il PID che contiene non è più in esecuzione, lo strumento sovrascriverà il PID
file con il PID corrente. Il file PID viene rimosso automaticamente alla chiusura dello strumento.

--collegare
tipo: stringa

Nome del modulo Perl da usare come plugin generico.

Specificare il nome del modulo Perl di un plug-in generico. Attualmente è utilizzato solo
per le statistiche (vedi "--statistics") e deve avere "new()" e un metodo "statistics()".

Il metodo "new( src =" $src, dst => $dst, opts => $o )> ottiene il sorgente e
DSN di destinazione e le relative connessioni al database, proprio come le specifiche della connessione
i plugin lo fanno. Ottiene anche un oggetto OptionParser ($o) per l'accesso alla riga di comando
opzioni (esempio: "$o-"get('purge');>).

Il metodo "statistics(\%stats, $time)" ottiene un hashref delle statistiche raccolte da
il processo di archiviazione e l'ora di inizio dell'intero processo.

--porta
forma breve: -P; tipo: int

Numero di porta da utilizzare per la connessione.

--solo-chiave-primaria
Solo colonne chiave primaria.

Una scorciatoia per specificare "--columns" con le colonne della chiave primaria. Questo è un
efficienza se vuoi solo eliminare le righe; evita di recuperare l'intera riga, quando
solo le colonne della chiave primaria sono necessarie per le istruzioni "DELETE". Vedi anche "--purge".

--progresso
tipo: int

Stampa le informazioni sullo stato di avanzamento ogni X righe.

Stampa l'ora corrente, il tempo trascorso e le righe archiviate ogni X righe.

--epurazione
Elimina invece di archiviare; permette di omettere "--file" e "--dest".

Consente l'archiviazione senza un argomento "--file" o "--dest", che è effettivamente un'eliminazione
poiché le righe sono state appena eliminate.

Se vuoi solo eliminare le righe, considera di specificare le colonne della chiave primaria della tabella
con "--solo-chiave-primaria". Ciò impedirà il recupero di tutte le colonne dal server per
nessuna ragione.

--eliminazione rapida
Aggiunge il modificatore QUICK alle istruzioni DELETE.

Vederehttp://dev.mysql.com/doc/en/delete.html> per i dettagli. Come affermato in
documentazione, in alcuni casi potrebbe essere più veloce utilizzare DELETE QUICK seguito da OPTIMIZE
TAVOLO. Puoi usare "--optimize" per questo.

--silenzioso
forma breve: -q

Non stampare alcun output, come per "--statistics".

Sopprime l'output normale, incluso l'output di "--statistics", ma non sopprime
l'output di "--why-quit".

--sostituire
Fa sì che gli INSERT in "--dest" vengano scritti come REPLACE.

--riprova
tipo: int; predefinito: 1

Numero di tentativi per timeout o deadlock.

Specifica il numero di volte in cui pt-archiver dovrebbe riprovare quando c'è un blocco InnoDB
attesa timeout o deadlock. Quando i tentativi sono esauriti, pt-archiver uscirà con an
errore.

Considera attentamente cosa vuoi che accada durante l'archiviazione tra un misto di
motori di archiviazione transazionali e non transazionali. L'INSERT a "--dest" e
DELETE da "--source" sono su connessioni separate, quindi in realtà non lo fanno
partecipano alla stessa transazione anche se si trovano sullo stesso server. Tuttavia, p-
archiver implementa semplici transazioni distribuite nel codice, quindi commit e rollback
dovrebbe avvenire come desiderato attraverso le due connessioni.

Al momento non ho scritto alcun codice per gestire gli errori con l'archiviazione transazionale
motori diversi da InnoDB. Richiedi quella funzione se ne hai bisogno.

--tempo di esecuzione
tipo: tempo

È ora di correre prima di uscire.

Suffisso opzionale s=secondi, m=minuti, h=ore, d=giorni; se nessun suffisso, viene utilizzato s.

--[no]safe-auto-incremento
predefinito: sì

Non archiviare righe con AUTO_INCREMENT massimo.

Aggiunge una clausola WHERE aggiuntiva per impedire a pt-archiver di rimuovere la riga più recente quando
crescente una chiave AUTO_INCREMENT a colonna singola. Questo protegge dal riutilizzo
AUTO_INCREMENT se il server si riavvia ed è abilitato per impostazione predefinita.

La clausola WHERE extra contiene il valore massimo della colonna di incremento automatico a partire da
l'inizio del processo di archiviazione o eliminazione. Se vengono inserite nuove righe mentre pt-archiver
è in esecuzione, non li vedrà.

--sentinella
tipo: stringa; default: /tmp/pt-archiver-sentinel

Esci se questo file esiste.

La presenza del file specificato da "--sentinel" causerà l'arresto di pt-archiver
archiviazione e uscita. L'impostazione predefinita è /tmp/pt-archiver-sentinel. Potresti trovare questo
utile per interrompere i lavori cron con grazia se necessario. Vedi anche "--stop".

--set-var
tipo: array

Imposta le variabili MySQL in questo elenco separato da virgole di coppie "variabile=valore".

Per impostazione predefinita, lo strumento imposta:

wait_timeout=10000

Le variabili specificate nella riga di comando sovrascrivono questi valori predefiniti. Per esempio,
specificando "--set-vars wait_timeout=500" si sovrascrive il valore predefinito di 10000.

Lo strumento stampa un avviso e continua se non è possibile impostare una variabile.

--condividi-blocco
Aggiunge il modificatore LOCK IN SHARE MODE alle istruzioni SELECT.

Vederehttp://dev.mysql.com/doc/en/innodb-locking-reads.html>.

--salta-controlli-chiavi-straniere
Disabilita i controlli delle chiavi esterne con SET FOREIGN_KEY_CHECKS=0.

--dormire
tipo: int

Tempo di sonno tra i prelievi.

Specifica la durata della sospensione tra le istruzioni SELECT. L'impostazione predefinita è non dormire a
tutto. Le transazioni NON vengono salvate e il file "--file" NON viene cancellato prima
dormire. Vedi "--txn-size" per controllarlo.

Se viene specificato "--commit-each", il commit e il flush avvengono prima di dormire.

--coef del sonno
tipo: galleggiante

Calcola "--sleep" come multiplo dell'ultimo tempo SELECT.

Se questa opzione è specificata, pt-archiver dormirà per il tempo di query dell'ultimo
SELECT moltiplicato per il coefficiente specificato.

Questo è un modo leggermente più sofisticato per limitare i SELECT: dormi a variazione
intervallo di tempo tra ogni SELECT, a seconda di quanto tempo impiegano le SELECT.

--presa
forme brevi; tipo: stringa

File socket da utilizzare per la connessione.

--fonte
tipo: DSN

DSN che specifica la tabella da cui archiviare (obbligatorio). Questo argomento è un DSN. Vedere
"OPZIONI DSN" per la sintassi. La maggior parte delle opzioni controlla come pt-archiver si connette a MySQL,
ma ci sono alcune opzioni DSN estese nella sintassi di questo strumento. La D, t e i
opzioni seleziona una tabella da archiviare:

--source h=mio_server,D=mio_database,t=mio_tbl

L'opzione a specifica il database da impostare come predefinito della connessione con USE. Se
l'opzione b è vera, disabilita la registrazione binaria con SQL_LOG_BIN. L'opzione m
specifica le azioni collegabili, che un modulo Perl esterno può fornire. Il solo
la parte richiesta è la tabella; altre parti possono essere lette da vari punti del
ambiente (come i file di opzioni).

La parte "i" merita una menzione speciale. Questo dice a pt-archiver quale indice dovrebbe
scansione per archiviare. Questo appare in un suggerimento FORCE INDEX o USE INDEX in SELECT
istruzioni utilizzate per recuperare le righe archiviabili. Se non specifichi nulla, pt-archiver
rileverà automaticamente un buon indice, preferendo una "CHIAVE PRIMARIA" se ne esiste una. Nel mio
sperimenta che di solito funziona bene, quindi la maggior parte delle volte puoi semplicemente omettere il
'io' parte.

L'indice viene utilizzato per ottimizzare gli accessi ripetuti alla tabella; pt-archiver ricorda
l'ultima riga che recupera da ogni istruzione SELECT e la usa per costruire un WHERE
clausola, utilizzando le colonne nell'indice specificato, che dovrebbe consentire a MySQL di avviare il
successivo SELEZIONARE dove è finito l'ultimo, piuttosto che potenzialmente eseguire la scansione dal
all'inizio della tabella con ogni SELECT successivo. Se stai usando esterno
plugin, vedere "ESTENDERE" per una discussione su come interagiscono con l'ascendente
indici.

Le opzioni 'a' e 'b' ti permettono di controllare come le istruzioni scorrono attraverso il binario
tronco d'albero. Se specifichi l'opzione 'b', la registrazione binaria sarà disabilitata su specificato
connessione. Se specifichi l'opzione 'a', la connessione "UTILIZZERÀ" quanto specificato
database, che è possibile utilizzare per impedire agli slave di eseguire gli eventi del registro binario
con le opzioni "--replicate-ignore-db". Queste due opzioni possono essere utilizzate in modo diverso
metodi per raggiungere lo stesso obiettivo: archiviare i dati fuori dal master, ma lasciarli sul
Schiavo. Ad esempio, è possibile eseguire un processo di eliminazione sul master e impedirne l'esecuzione
accadendo sullo schiavo usando il tuo metodo preferito.

AVVERTIMENTO: Utilizzo di un'opzione DSN del file delle opzioni predefinite (F) che definisce un socket per
"--source" fa in modo che pt-archiver si connetta a "--dest" usando quel socket a meno che non sia un altro
socket per "--dest" è specificato. Ciò significa che pt-archiver potrebbe connettersi in modo errato
a "--source" quando si intende connettersi a "--dest". Per esempio:

--source F=host1.cnf,D=db,t=tbl --dest h=host2

Quando pt-archiver si connette a "--dest", host2, si connetterà tramite "--source",
host1, socket definito in host1.cnf.

--statistiche
Raccogliere e stampare statistiche sui tempi.

Fa in modo che pt-archiver raccolga statistiche temporali su ciò che fa. Queste statistiche
sono disponibili per il plugin specificato da "--plugin"

A meno che non specifichi "--quiet", "pt-archiver" stampa le statistiche quando esce. Il
le statistiche hanno questo aspetto:

Started at 2008-07-18T07:18:53, ended at 2008-07-18T07:18:53
Fonte: D=db,t=tabella
SELEZIONA 4
INSERTO 4
ELIMINA 4
Tempo conteggio azioni Pct
impegna 10 0.1079 88.27
seleziona 5 0.0047 3.87
cancellando 4 0.0028 2.29
inserendo 4 0.0028 2.28
altro 0 0.0040 3.29

Le prime due (o tre) righe mostrano gli orari e le tabelle di origine e destinazione. Il
le tre righe successive mostrano quante righe sono state recuperate, inserite ed eliminate.

Le righe rimanenti mostrano i conteggi e i tempi. Le colonne sono l'azione, il totale
il numero di volte in cui l'azione è stata cronometrata, il tempo totale impiegato e la percentuale di
tempo di esecuzione totale del programma. Le righe sono ordinate in base al tempo totale decrescente. Il
l'ultima riga è il resto del tempo non esplicitamente attribuito a nulla. Le azioni saranno
variano a seconda delle opzioni della riga di comando.

Se viene dato "--why-quit", il suo comportamento cambia leggermente. Questa opzione lo fa
stampa il motivo dell'uscita anche quando è solo perché non ci sono più righe.

Questa opzione richiede il modulo standard Time::HiRes, che fa parte del core Perl on
versioni di Perl ragionevolmente nuove.

--fermare
Interrompi l'esecuzione delle istanze creando il file sentinella.

Fa in modo che pt-archiver crei il file sentinel specificato da "--sentinel" e esca.
Questo dovrebbe avere l'effetto di fermare tutte le istanze in esecuzione che stanno guardando il
stesso file sentinella.

--txn-dimensione
tipo: int; predefinito: 1

Numero di righe per transazione.

Specifica la dimensione, in numero di righe, di ogni transazione. Zero disabilita le transazioni
del tutto. Dopo che pt-archiver ha elaborato questo numero di righe, esegue il commit di entrambe le
"--source" e "--dest" se fornito, e svuota il file fornito da "--file".

Questo parametro è fondamentale per le prestazioni. Se stai archiviando da un server live,
che, ad esempio, sta svolgendo un lavoro OLTP pesante, è necessario scegliere un buon equilibrio tra
dimensione della transazione e sovraccarico del commit. Transazioni più grandi creano la possibilità di
più conflitto di lock e deadlock, ma le transazioni più piccole causano più frequenti
sovraccarico di commit, che può essere significativo. Per dare un'idea, su un piccolo set di prova I
ha lavorato durante la scrittura di pt-archiver, un valore di 500 ha fatto sì che l'archiviazione richiedesse circa 2
secondi per 1000 righe su un'istanza MySQL altrimenti silenziosa sul mio computer desktop,
archiviazione su disco e su un'altra tabella. Disabilitazione delle transazioni con valore zero,
che attiva il commit automatico, le prestazioni sono diminuite a 38 secondi per mille righe.

Se non stai archiviando da o verso un motore di archiviazione transazionale, potresti volerlo
disabilita le transazioni in modo che pt-archiver non tenti di eseguire il commit.

--utente
forma breve: -u; tipo: stringa

Utente per il login se non utente corrente.

--versione
Mostra la versione ed esci.

--[no]verifica-versione
predefinito: sì

Controlla la versione più recente di Percona Toolkit, MySQL e altri programmi.

Questa è una funzione standard di "verifica automatica degli aggiornamenti", con due aggiuntivi
caratteristiche. Innanzitutto, lo strumento controlla la versione di altri programmi sul sistema locale in
oltre alla propria versione. Ad esempio, controlla la versione di ogni server MySQL
si connette a Perl e al modulo Perl DBD::mysql. In secondo luogo, controlla e avverte
sulle versioni con problemi noti. Ad esempio, MySQL 5.5.25 aveva un bug critico e
è stato ripubblicato come 5.5.25a.

Eventuali aggiornamenti o problemi noti vengono stampati su STDOUT prima del normale output dello strumento.
Questa caratteristica non dovrebbe mai interferire con il normale funzionamento dello strumento.

Per maggiori informazioni visita .

--dove
tipo: stringa

Clausola WHERE per limitare le righe da archiviare (obbligatorio).

Specifica una clausola WHERE per limitare le righe da archiviare. Non includere la parola
DOVE. Potrebbe essere necessario citare l'argomento per impedire alla shell di interpretarlo.
Per esempio:

--where 'ts < data_corrente - intervallo 90 giorni'

Per sicurezza, è richiesto "--where". Se non hai bisogno di una clausola WHERE, usa
"--dove" 1=1.

--perché-chiudere?
Stampa il motivo dell'uscita a meno che le righe non siano esaurite.

Fa sì che pt-archiver stampi un messaggio se esce per qualsiasi motivo diverso dall'esecuzione
fuori righe da archiviare. Questo può essere utile se hai un cron job con "--run-time"
specificato, ad esempio, e vuoi essere sicuro che pt-archiver finisca prima
a corto di tempo.

Se viene fornito "--statistics", il comportamento viene leggermente modificato. Stamperà il
motivo per uscire anche quando è solo perché non ci sono più righe.

Questo output viene stampato anche se viene fornito "--quiet". È così che puoi inserire "pt-archiver"
un lavoro "cron" e ricevi un'email se c'è un'uscita anomala.

DSN VERSIONI

Queste opzioni DSN vengono utilizzate per creare un DSN. Ogni opzione è data come "opzione=valore".
Le opzioni fanno distinzione tra maiuscole e minuscole, quindi P e p non sono la stessa opzione. Non ci può essere
spazio bianco prima o dopo "=" e se il valore contiene spazi bianchi deve essere citato.
Le opzioni DSN sono separate da virgole. Vedi la manpage di percona-toolkit per tutti i dettagli.

· A

copia: no

Database da UTILIZZARE durante l'esecuzione di query.

· A

dsn: set di caratteri; copia: sì

Set di caratteri predefinito.

· B

copia: no

Se true, disabilita binlog con SQL_LOG_BIN.

· D

dsn: banca dati; copia: sì

Database che contiene la tabella.

F

dsn: mysql_read_default_file; copia: sì

Leggi solo le opzioni predefinite dal file dato

· H

dsn: ospite; copia: sì

Connettiti all'host.

· io

copia: sì

Indice da usare.

· l

copia: sì

Abilita esplicitamente LOAD DATA LOCAL INFILE.

Per qualche ragione, alcuni fornitori compilano libmysql senza --enable-local-infile
opzione, che disabilita l'istruzione. Questo può portare a situazioni strane, come il
server che consente LOCAL INFILE, ma il client genera eccezioni se viene utilizzato.

Tuttavia, fintanto che il server consente LOAD DATA, i client possono facilmente riattivarlo; Vedere
e
<http://search.cpan.org/~capttofu/DBD-mysql/lib/DBD/mysql.pm>. Questa opzione non
esattamente quello.

Anche se non abbiamo trovato un caso in cui l'attivazione di questa opzione porta a errori o differenze
comportamento, per sicurezza, questa opzione non è attiva per impostazione predefinita.

· M

copia: no

Nome del modulo plug-in.

· P

dsn: password; copia: sì

Password da utilizzare durante la connessione. Se la password contiene virgole, devono essere sfuggite
con una barra rovesciata: "esame\,ple"

· P

dsn: porta; copia: sì

Numero di porta da utilizzare per la connessione.

· S

dsn: mysql_socket; copia: sì

File socket da utilizzare per la connessione.

· T

copia: sì

Tabella da archiviare da/a.

· tu

dsn: utente; copia: sì

Utente per il login se non utente corrente.

ESTENDERE

pt-archiver è estensibile collegando moduli Perl esterni per gestire un po' di logica e/o
Azioni. Puoi specificare un modulo sia per "--source" che per "--dest", con la 'm'
parte della specifica. Per esempio:

--source D=test,t=test1,m=My::Modulo1 --dest m=My::Modulo2,t=test2

Ciò farà sì che pt-archiver carichi i pacchetti My::Module1 e My::Module2, creare
istanze di essi e quindi effettuare chiamate ad essi durante il processo di archiviazione.

Puoi anche specificare un plugin con "--plugin".

Il modulo deve fornire questa interfaccia:

new(dbh => $dbh, db => $db_name, tbl => $tbl_name)
Al costruttore del plugin viene passato un riferimento all'handle del database, il database
nome e nome della tabella. Il plugin viene creato subito dopo l'apertura di pt-archiver
connessione, e prima di esaminare la tabella fornita negli argomenti. Questo dà il
plug-in la possibilità di creare e popolare tabelle temporanee o eseguire altre operazioni di configurazione.

before_begin(cols => \@cols, allcols => \@allcols)
Questo metodo viene chiamato appena prima che pt-archiver inizi a scorrere le righe e
archiviandole, ma dopo aver eseguito tutte le altre operazioni di configurazione (esame delle strutture delle tabelle,
progettazione di query SQL e così via). Questa è l'unica volta che pt-archiver dice al plugin
nomi di colonna per le righe che passerà al plugin durante l'archiviazione.

L'argomento "cols" sono i nomi delle colonne che l'utente ha chiesto di archiviare, sia per
predefinito o dall'opzione "--columns". L'argomento "allcols" è l'elenco delle colonne
i nomi per ogni riga pt-archiver verranno recuperati dalla tabella di origine. Potrebbe valerne di più
colonne rispetto a quanto richiesto dall'utente, poiché necessita di alcune colonne per il proprio utilizzo. quando
le successive funzioni del plugin ricevono una riga, è l'intera riga contenente tutto l'extra
colonne, se presenti, aggiunte alla fine.

is_archivable(riga => \@riga)
Questo metodo viene chiamato per ogni riga per determinare se è archiviabile. Questo
si applica solo a "--source". L'argomento è la riga stessa, come arrayref. Se la
il metodo restituisce true, la riga verrà archiviata; altrimenti verrà saltato.

Saltare una riga aggiunge complicazioni per gli indici non univoci. Normalmente pt-archiver usa a
Clausola WHERE progettata per indirizzare l'ultima riga elaborata come punto in cui avviare la scansione
per la successiva istruzione SELECT. Se hai saltato la riga restituendo false da
è_archiviabile(), pt-archiver potrebbe entrare in un ciclo infinito perché la riga è ancora
esiste. Pertanto, quando specifichi un plugin per l'argomento "--source", pt-archiver
cambierà leggermente la sua clausola WHERE. Invece di iniziare con "maggiore o uguale"
a" l'ultima riga elaborata, inizierà "strettamente maggiore di".
va bene su indici univoci come le chiavi primarie, ma può saltare le righe (lasciare buchi) su
indici non univoci o quando si sale solo la prima colonna di un indice.

"pt-archiver" cambierà la clausola allo stesso modo se specifichi "--no-delete",
perché di nuovo un ciclo infinito è possibile.

Se specifichi l'opzione "--bulk-delete" e restituisci false da questo metodo,
"pt-archiver" potrebbe non fare quello che vuoi. La riga non verrà archiviata, ma lo sarà
cancellato, poiché le eliminazioni in blocco operano su intervalli di righe e non sanno quali righe sono
plugin selezionato da mantenere.

Se specifichi l'opzione "--bulk-insert", il valore di ritorno di questo metodo influenzerà
se la riga viene scritta nel file temporaneo per l'inserimento in blocco, quindi gli inserimenti in blocco
funzionerà come previsto. Tuttavia, gli inserimenti in blocco richiedono eliminazioni in blocco.

before_delete(riga => \@riga)
Questo metodo viene chiamato per ogni riga appena prima di essere eliminata. Questo vale solo per
"--fonte". Questo è un buon posto per gestire le dipendenze, come l'eliminazione
cose che hanno una chiave esterna per la riga che stai per eliminare. Potresti anche usare
questo per archiviare ricorsivamente tutte le tabelle dipendenti.

Questo metodo plugin viene chiamato anche se viene fornito "--no-delete", ma non se
Viene fornito "--bulk-delete".

before_bulk_delete(first_row => \@row, last_row => \@row)
Questo metodo viene chiamato appena prima dell'esecuzione di un'eliminazione in blocco. È simile a
metodo "before_delete", eccetto che i suoi argomenti sono la prima e l'ultima riga dell'intervallo
essere cancellato. Viene chiamato anche se viene fornito "--no-delete".

before_insert(riga => \@riga)
Questo metodo viene chiamato per ogni riga appena prima che venga inserita. Questo vale solo per
"--dest". Potresti usarlo per inserire la riga in più tabelle, magari con an
ON DUPLICATE KEY UPDATE clausola per creare tabelle di riepilogo in un data warehouse.

Questo metodo non viene chiamato se viene fornito "--bulk-insert".

before_bulk_insert(first_row => \@row, last_row => \@row, nomefile =>
bulk_insert_nomefile)
Questo metodo viene chiamato appena prima dell'esecuzione di un inserimento in blocco. È simile a
metodo "before_insert", eccetto che i suoi argomenti sono la prima e l'ultima riga dell'intervallo
essere cancellato.

custom_sth(row => \@row, sql => $sql)
Questo metodo viene chiamato appena prima di inserire la riga, ma dopo "prima_inserimento()". Esso
consente al plugin di specificare una diversa istruzione "INSERT", se lo si desidera. Il ritorno
value (se presente) deve essere un handle di istruzione DBI. Il parametro "sql" è il testo SQL
utilizzato per preparare l'istruzione "INSERT" predefinita. Questo metodo non viene chiamato se tu
specificare "--bulk-insert".

Se non viene restituito alcun valore, viene utilizzato l'handle dell'istruzione "INSERT" predefinito.

Questo metodo si applica solo al plugin specificato per "--dest", quindi se il tuo plugin non lo è
facendo quello che ti aspetti, controlla di averlo specificato per la destinazione e non per il
fonte.

custom_sth_bulk(first_row => \@row, last_row => \@row, sql => $sql, nomefile =>
$bulk_insert_nomefile)
Se hai specificato "--bulk-insert", questo metodo viene chiamato appena prima del bulk
inserire, ma dopo "prima_bulk_insert()", e gli argomenti sono diversi.

Il valore di ritorno di questo metodo ecc. è simile al "personalizzato_qc()" metodo.

dopo_finitura()
Questo metodo viene chiamato dopo che pt-archiver esce dal ciclo di archiviazione, esegue il commit di tutto il database
gestisce, chiude "--file" e stampa le statistiche finali, ma prima dell'esecuzione di pt-archiver
ANALIZZA o OTTIMIZZA (vedi "--analyze" e "--optimize").

Se specifichi un plugin sia per "--source" che per "--dest", i costrutti pt-archiver,
prima_inizio()e chiama dopo_finitura() sui due plugin nell'ordine "--source",
"--dest".

pt-archiver presuppone che controlli le transazioni e che il plugin NON eseguirà il commit o il roll
indietro l'handle del database. L'handle del database passato al costruttore del plugin è il
stesso handle che pt-archiver usa da solo. Ricorda che "--source" e "--dest" sono separati
maniglie.

Un modulo di esempio potrebbe essere simile a questo:

pacchetto My::Modulo;

sottonuovo {
mio ($classe, %args) = @_;
return benedica(\%args, $class);
}

sub prima_inizio {
mio ( $self, %args ) = @_;
# Salva i nomi delle colonne per dopo
$self->{cols} = $args{cols};
}

sub è_archiviabile {
mio ( $self, %args ) = @_;
# Fai un po' di logica avanzata con $args{row}
1 ritorno;
}

sub before_delete {} # Non eseguire alcuna azione
sub before_insert {} # Non eseguire alcuna azione
sub custom_sth {} # Non eseguire alcuna azione
sub after_finish {} # Non eseguire alcuna azione

1;

AMBIENTE

La variabile di ambiente "PTDEBUG" abilita l'output di debug dettagliato su STDERR. Abilitare
eseguire il debug e acquisire tutto l'output in un file, eseguire lo strumento come:

PTDEBUG=1 pt-archiver ... > FILE 2>&1

Fai attenzione: l'output di debug è voluminoso e può generare diversi megabyte di output.

SISTEMA REQUISITI

Hai bisogno di Perl, DBI, DBD::mysql e alcuni pacchetti di base che dovrebbero essere installati in qualsiasi
versione ragionevolmente nuova di Perl.

Usa pt-archiverp online utilizzando i servizi onworks.net