Ri: Velocizza tabelle/AggiornaIn primo luogo, una barra di avanzamento potrebbe aiutare l'utente
... leggermente: per capire che Jmp non va in crash, ma fa qualcosa in background.
Ri: Velocizza tabelle/Aggiornaprova solo questo - 40 studenti, N x:
Names Default to Here(1);
// adjust the size and check// +1 means: data table size x 2// ... and update time x 4
mySize=12;
dt0 = Open( "$SAMPLE_DATA/Big Class.jmp" );
increaseSize= Function({dt,cycles},
for(i=1,i<=cycles,i++,
dt << Concatenate(dt, Append to first table))
);
increaseSize(dt0,mySize);
show(nrows (dt0));
dt2 = subset(dt0);
//if you are brave, enable this:
/*for (i=1,i<5,i++,
dt2 << new column("new", set each value (random uniform()))
);*/
//generate a list of columns which should be added
Cols = dt2 << get column names();
remove from (cols, {1,2,3} );
dt0 << Delete Columns( :height, :weight );
t1=hptime();
Eval(Eval Expr(dt0 << Update(
With( dt2 ),
Match Columns( :name = :name, :sex = :sex ),
Add Columns from Update Table(
Expr(Cols)
),
Replace Columns in Main Table( None )
)));
show((hptime()-t1)/1000000); // on my notebook: ~ 15s per column
close(dt0, noSave);
close(dt2, noSave);Ri: Velocizza tabelle/AggiornaInteressante: disabilitare il
remove from (cols, {1,2,3} );costa 10s aggiuntivi con Tabelle/Aggiornamento.
Sembra che la corrispondenza delle righe non venga eseguita solo per ogni colonna che viene aggiunta.
È anche fatto in una certa misura per le colonne che sono già presenti.
Ri: Velocizza tabelle/AggiornaUno potrebbe sostituire il Tabelle/Aggiornamento piattaforma con una definita dall'utente.
- imposta Aggiungi/Sostituisci colonne su Selezionato/Nessuno (invece di Tutto tutto ) --> vengono valutate meno colonne per l'anteprima
- un pulsante definito dall'utente OK (alta velocità) può attivare Tables/Join dopo aver convertito le impostazioni
tramite UpdateHS()
Names Default to Here(1);
dt = Current Data Table();
If(isempty(dt) | N rows(dt )==0, stop());
Try( myDTUpdate << close window() );
myDTUpdate = New Window( "Update - high speed", dt << update() );
myDTUpdate[Lineup Box( 1 )] << Prepend( mb = MouseBox( Button Box( "OK (HS)", updateHS() ) ) );
mb << settooltip( "high speed via Tables/join" );
//DtUpdateHS:myDTUpdate["Preview", CheckboxBox( 1 )] << set( 1, 0 );
myDTUpdate["Add Columns from Update Table", Radio Box( 1 )] << set( 3 );
myDTUpdate["Replace Columns in Main Table", Radio Box( 1 )] << set( 2 );
Ri: Velocizza tabelle/AggiornaSembra che si potrebbe ottenere un enorme miglioramento se UPDATE non utilizzasse la propria funzione
... ma ha appena attivato JOIN in background.
Ri: Velocizza tabelle/AggiornaPer quanto riguarda le differenze di velocità tra Tables/Join e Tables/Update, ho ricevuto il feedback da Jmp Support (TS-00044631) che
in base alla progettazione, Aggiorna e Partecipa fanno cose diverse quando ci sono più corrispondenze.[...] Join utilizza l'estensione Primo match, quindi non appena trova una corrispondenza è fatta.
[...] Aggiorna [esamina] tutte quelle corrispondenze, applicandole tutte e solo le l'ultimo bastoni. *)
Questo spiega l'enorme differenza temporale per il caso speciale di cui sopra a causa delle molte copie dei dati.
Quindi, fai attenzione quando usi Aggiorna se hai tabelle con valori non univoci e molte colonne.
D'altra parte, il problema verrà risolto facilmente se Jmp verificherà la presenza di valori non univoci e molte colonne prima che decida di calcolare l'anteprima 
*) La differenza tra Tables/Join e Tables/Update è ben illustrata da questo esempio di Jmp Support:
Si noti che il Partecipato il tavolo ha tutto 1 è in col2, mentre il Aggiornato il tavolo ha tutto 3 è in col2.
dt0 = New Table( "MyTable",
Add Rows( 3 ),
New Column( "col1",
Character, "Nominal",
Set Values({"a", "a", "a"})
),
New Column( "col2",
Numeric,
"Continuous",
Set Values([1, 2, 3])
)
);
dt2 = subset( dt0 );
Cols = dt2 << get column names();
Remove From( cols, {1} );
dt0 << Delete Columns( :col2 );
Eval(Eval Expr(dt0 << Join(
With( dt2 ),
Select( :col1 ),
SelectWith(Expr( Cols) ),
By Matching Columns( :col1 = :col1 ),
Drop multiples( 0, 1 ),
Preserve main table order( 1 ),
)));
Eval(
Eval Expr(
dt0 << Update(
With( dt2 ),
Match Columns( :col1 = :col1 ),
Add Columns from Update Table( Expr( Cols ) ),
Replace Columns in Main Table( None )
)
)
);Re: Velocizzare tabelle/aggiornamenti
@hogi ha scritto:
Ma temo che la funzione controlli solo la lunghezza della tabella e non il numero di colonne.
In realtà, sembra che Tables/Update controlli il numero di colonne
- se sono presenti > 100 colonne, l'aggiornamento automatico è disabilitato.
Ma sembra che Jmp controlli solo il numero di righe/colonne della tabella principale
non della seconda tabella.
Quindi, se il # di colonne della tabella principale è troppo grande, l'anteprima è disabilitata, sebbene # colonne (tabella principale) non abbia alcun impatto sulla velocità
Names Default to Here(1);
// adjust the size and check// +1 means: data table size x 2//
mySize1=7;
dt0 = Open( "$SAMPLE_DATA/Big Class.jmp" );
new column ("one", set each value(1));
increaseSize= Function({dt,cycles},
for(i=1,i<=cycles,i++,
dt << Concatenate(dt, Append to first table))
);
increaseSize(dt0,mySize1);
numberRows0 = Nrows(dt0);
dt2 = dt0 << Subset( All rows, columns( :name, :age ) );
for (i=1,i<1000,i++,
dt2 << new column("new", set each value (random uniform()))
);
numberRows2 = Nrows(dt2);
dt2Name = dt2 << get name();
New Column( "Rank", Formula( Col Rank( Row(), :name ) ));
Try(updateWindow << close window());
updateWindow = New window("are you brave?",
dt 0 << update()
);
updateWindow[Text Box(1)] << background color (Orange) << text color (white )<< set font ("Arial Black", 10)
<< set text("The tables have <10k rows. \!nBut the second table has > 1000 columns. \!nSo I deactivated the preview for you.\!nIf you have some time, activate it again ...");
updateWindow["Preview", CheckboxBox( 1 )] << set( 1, 0 );
updateWindow[ListBoxBox( 1 )] << set selected (loc(updateWindow[ListBoxBox( 1 )] <<GET items=""></GET>
Modificare:
A volte vale la pena aggiungere un'ulteriore condizione di corrispondenza (ad esempio la classificazione nella tabella di origine)
Ciò riduce il numero di corrispondenze e accelera enormemente l'anteprima e l'aggiornamento effettivo.
Accelerare le tabelle/AggiornareCosa ti ha ispirato a richiedere questa lista dei desideri?
☐ nuova fantastica funzionalità
☑ potrebbe aiutare molti utenti!
☑ rimuove un "bug"
☐ bello da avere
☐ nessuno ne ha bisogno
#lamiaTop10_2023
(o questa o Tabelle join: opzione per aggiornare la tabella principale )
abbiamo una soluzione alternativa -> non ne abbiamo più bisogno
Tables Update è una piattaforma davvero utile che può essere utilizzata per unire colonne in una tabella dati o per aggiornare colonne con i dati di un'altra tabella dati.
A volte però l'utente deve attendere a lungo prima che Jmp completi l'aggiornamento di una tabella dati, anche nel caso di tabelle di dati di medie dimensioni.
A volte, Jmp si blocca durante la modifica delle impostazioni nell'interfaccia utente grafica di aggiornamento.
Sembra che Jmp si sia bloccato, ma dopo alcuni minuti (o talvolta: ore), Jmp termina il calcolo per l'anteprima dei dati e dà nuovamente all'utente la possibilità di modificare le impostazioni.
È chiaro che ci vuole un po' di tempo per abbinare centinaia di migliaia di valori in una tabella con i valori in un'altra tabella.
Ma mi sorprende che unire due colonne richieda il doppio del tempo che unire una colonna sola
La fase di abbinamento viene attivata nuovamente per ogni colonna unita oppure è in realtà l'ordinamento dei valori a richiedere così tanto tempo?
Spesso non ho identificatori univoci nella tabella di origine: un singolo valore di corrispondenza compare più volte in una colonna, con valori identici anche nella colonna da unire. In questo caso, mi chiedo se il valore della prima corrispondenza venga immesso nella tabella dati di destinazione, quindi sostituito dal secondo, e così via...
Questa operazione potrebbe essere accelerata cercando l'ultimo valore corrispondente nella tabella di origine e inserendo semplicemente questo valore.
Un grande svantaggio della piattaforma di aggiornamento:
Inizia attivando le opzioni Aggiungi colonne e Sostituisci colonne .
Se una tabella ha ad esempio 1000 colonne, ci vorrà un po' di tempo prima che tutte le colonne vengano aggiunte alla finestra di anteprima.
Il problema è proporzionale a rows_main x rows_2nd x columns_2nd.
E per quanto stupido io sia, spesso inizio definendo le colonne di corrispondenza... il che mi consente di fare una lunga passeggiata prima di poter scegliere la/le colonna/e (1-2) che voglio effettivamente aggiungere alla tabella.
Esiste una funzionalità che disattiva l'anteprima se la tabella è troppo grande.
Ma temo che la funzione controlli solo la lunghezza della tabella e non il numero di colonne.
Oppure la soglia è troppo alta?
Raccontaci la tua esperienza: con quale frequenza hai dovuto attendere che la sessione Jmp si riavviasse dopo un aggiornamento della scheda di anteprima?
Un altro problema è il pulsante di richiamo
(trattato qui: Disabilitare l'anteprima durante il riempimento della GUI tramite Richiamo )
Dopo aver cliccato su Richiama, il menu Aggiorna si riempie con le impostazioni salvate e dopo ogni modifica di un'impostazione GUI sembra che ci sia un aggiornamento della scheda di anteprima.
Quindi, se vuoi unire tabelle di dati di grandi dimensioni, anche se vuoi solo aggiungere una singola colonna, non osare premere Richiama... prima di aver disattivato l'anteprima.
Quale miglioramento vorresti vedere?
Potresti migliorare le prestazioni di Tables/Update?
Perché questa idea è importante?
Tables/Update è una funzione meravigliosa. La scheda Preview è incredibilmente utile, non voglio lavorare senza.
Ma sto iniziando a diventare paranoico: quanto tempo ci vorrà la prossima volta che proverò ad aggiungere colonne a una tabella di dati?
Fusione e pulizia dei datiRe: Velocizza tabelle/Aggiornabassa priorità da parte nostra: abbiamo implementato una soluzione alternativa seguendo l'idea di https://community.jmp.com/t5/JMP-Wish-List/Speed-up-Tables-Update/idc-p/653334/highlight/true#M4531
