Operazioni sui dataset¶

Workspace¶

E’ possibile caricare più di un file di dati, allo scopo, per esempio, di alternare la fonte di dati delle tavole. Inoltre alcuni comandi generano o richiedono un ulteriore dataset. In tali casi, i dati devono essere assegnati a un’area di lavoro differente (workspace), utilizzando il parametro :ws => :name, dove :name è un simbolo. pTabs2 utilizza invece automaticamente dei numero progressivi come identificativo del workspace. Il workspace di default è 0.

 spss.open "dati"                       # carica i dati nel workspace 0
 spss.open "altri_dati", :ws => :ds2    # carica i dati nel workspace :ds2
 xlsx.open "altri_dati", :ws => :xdata  # carica i dati nel workspace :xdata

ws¶

ws :name attiva un dataset differente e lo rende disponibile per l’elaborazione.

ws.rename¶

ws.rename :newname rinomina il dataset attivo come :newname.

ws.close¶

ws.close :name chiude il dataset indicato o quello attivo, se non specificato il nome.

ws.new¶

ws.new :name crea un nuovo workspace con un dataset vuoto.

ws.copy¶

ws.copy :name, [all: true|false, activate: true|false] fa una copia del dataset attivo nel workspace :name. all copia tutti i dati anche se attivo un filtro (default true). activate attiva il nuovo dataset (default false).

ws?¶

ws? elenca i dataset esistenti.

> Datasets:
+---+--------+------+------+--------+---------+----------+---------+----------------+
| # | active |  ws  | name | fields | records | filtered | filter  | filter caption |
+---+--------+------+------+--------+---------+----------+---------+----------------+
| 1 |   *    |  0   |      |     97 |     300 |          |         |                |
| 2 |        | stk1 |      |      3 |     600 |       72 | cell=10 | Base: Cell 10  |
| 3 |        | stk2 |      |      4 |   13800 |          |         |                |
+---+--------+------+------+--------+---------+----------+---------+----------------+

ws.list¶

ws.list restituisce l’elenco (array) dei simboli dei nomi dei dataset.

# unisce tra loro i workspace
ws.list.each_with_index do |name, index|
  if index == 0
    ws name
  else
    union name, :mode => :union
  end
end

<<

n¶

n seleziona le prime n osservazioni.

 n 100

<<

sample¶

sample estrae un sample delle osservazioni.

Se viene specificato il nome di una variabile e un valore i casi casi estratti vengono solo marcati, altrimenti i casi non estratti vengono esclusi dal dataset. Se è attivo un filtro le osservazioni vengono estratte tra i casi attivi.

Parametri:

il numero di osservazioni da estrarre

:varname => {code1 => N, code2 => N}: le probabilità di estrazione rispetto a una variabile

:flag => :varname | [:varname, value] | {:varname => value}: il nome e il valore di una variabile per identificare i casi estratti

:seed => number: un seed per replicare i risultati

:repeat => true|false: estrae record già estratti se il numero di record da estrarre è maggiore del numero dei record disponibili (default false)

 sample 100

 sample 100, :sesso => {1 => 30, 2 => 70}

 sample 100, :sesso => {1 => 30, 2 => 70}, :flag => [:sample, 1]
 filter "!sample"
 sample 100, :sesso => {1 => 30, 2 => 70}, flag: {:sample => 2}
 all

<<

shuffle¶

shuffle riordina casualmente i record del dataset.

Parametri:

number un seed per replicare i risultati

 shuffle

<<

sort¶

sort riordina i record del dataset rispetto alle variabili date in senso ascendente (:a) o discendente (:d).

Parametri:

var|varlist: la variabile o la lista di variabili su cui ordinare i dati

var => :a|:d: la variabile e il simbolo per la direzione dell’ordinamento: :a|:d

[var, :a|:d]: la variabile e il simbolo per la direzione dell’ordinamento: :a|:d

 sort :ser_no

 sort :cognome, [:eta, :d]

 sort :prof, [:sesso, :d], :name
 sort :prof => :a, :sesso => :d, :name => :a

<<

ddup¶

ddup identifica ed elimina i record duplicati.

E’ possibile indicare le variabili su cui effettuare il controllo dei record duplicati oppure utilizzare tutte le variabili.

Parametri:

varlist: variabili su cui effettuare il controllo

:show => true|false: visualizza il report con i casi duplicati: true|false, default true

:drop => true|false: elimina i record duplicati: true|false, default true

:flag => :varname | [:varname, value] | {:varname => value}: il nome e il valore di una variabile per identificare i casi duplicati

:prog => :varname | [:varname, start_value] | {:varname => start_value}: il nome di una variabile in cui inserire un progressivo dei record doppi. start_value è il valore da cui pardire: default 0.

:first => true|false: tiene il primo record tra quelli duplicati e elimina gli altri: true|false, default true

:last => true|false: tiene l’ultimo record tra quelli duplicati e elimina gli altri: true|false, default false

:info => [varlist]: aggiunge ulteriori variabili da visualizzare nel report: [varlist]

:xlsx => filename: nome del file xlsx (senza estensione) in cui salvare la tabella

 # elimina i record che risultano doppi rispetto a tutte le variabili
 ddup

 # elimina i record che risultano doppi per le variabili id_fam e id_pers; tiene l'ultimo record
 ddup :id_fam, :id_pers, :last => true

 # non elimina i record, produce solo il report aggiungendo delle variabili
 ddup :ser_no, :drop => false, :info => [:sesso, :area, :name]

 # numera i record doppi e poi genera un nuovo id univoco
 ddup :ser_no, :prog => [:ndup, 1]
 compute :newid => "ser_no*10+ndup"

ddup :ser_no, :info => [:etaq, :area, :name]

+ sono stati trovati ed eliminati 12 record duplicati

+----+--------+------+------+----------------------+-------+-----------+
| #  | ser_no | etaq | area |         name         | [dup] | [deleted] |
+----+--------+------+------+----------------------+-------+-----------+
|  1 |      1 |   25 |    1 | SKWAJUI ILOGWDPIVA   |   1   |           |
|  2 |      1 |   30 |    1 | XMZXPE ILEWGYS       |   -   |     *     |
|  3 |      2 |   24 |    1 | GSSDMV HJLOYTEY      |   2   |           |
|  4 |      2 |   15 |    1 | JNXFDWSOEJH JPVQCF   |   -   |     *     |
|  5 |      3 |   15 |    1 | JCZOYHSFBZN FBVREQHH |   3   |           |
|  6 |      3 |   31 |    1 | IZOQJYGAX ALSVOXA    |   -   |     *     |
| 33 |      3 |   25 |    1 | FQZASOTDJ UQYRGKRR   |   -   |     *     |
| 45 |      3 |   28 |    1 | BLVLLEBCKBP FKMISPF  |   -   |     *     |
|  7 |      4 |   31 |    1 |                      |   4   |           |
|  8 |      4 |   25 |    1 | OFYWVGC DUCYDMQIASW  |   -   |     *     |
|  9 |      5 |   34 |    1 | EBCQROL ASZCUE       |   5   |           |
| 10 |      5 |   30 |    1 | TXZYWQNQMEMT RYWJNSG |   -   |     *     |
| 11 |      6 |   25 |    1 | BYYLTW AFALISHXHJ    |   6   |           |
| 12 |      6 |   33 |    1 | RYYEYFT DSYWOWZ      |   -   |     *     |
| 13 |      7 |   25 |    1 | LLCPEFINVD TTUFESW   |   7   |           |
| 14 |      7 |   30 |    1 | KDGJNB IXHKKYBU      |   -   |     *     |
| 15 |      8 |   20 |    1 | WFIOQXFL GJNMZCWNZW  |   8   |           |
| 16 |      8 |   25 |    1 | KTFKDRCEQXMP NREDCXC |   -   |     *     |
| 17 |      9 |   24 |    1 | GOMSFQWZPFBI VJBKNUQ |   9   |           |
| 18 |      9 |   25 |    1 | USEFPLYQT OOPXIVWE   |   -   |     *     |
| 19 |     10 |   27 |    1 | DQLLOWOO QZCQXWG     |  10   |           |
| 20 |     10 |   32 |    1 | RZXBOAASXJ FCQORRS   |   -   |     *     |
+----+--------+------+------+----------------------+-------+-----------+

<<

union¶

union unisce i casi di un dataset al dataset attivo. Il dataset da accodare deve essere stato precedentemente caricato in un’altra area di lavoro (workspace).

Parametri:

:id: l’id del dataset da accodare al datset attivo

:mode: definisce l’insieme di variabili del dataset risultante:

:left o :x: tiene solo le variabili presenti nel dataset attivo (default)

:right o :y: tiene solo le variabili presenti nel secondo dataset

:union: tiene tutte le variabili

:inter[section]: tiene solo le variabili presenti in entrambi i dataset

:diff[erence]: tiene solo le variabili presenti in uno solo dei due dataset

:keep => varlist: variabili del dataset che si sta unendo da includere

:drop => varlist: variabili del dataset che si sta unendo da escludere

:flag => :varname | [:varname, value] | {:varname => value} flag che identifica i record aggiunti

:id => :varname | [:varname, start_value | {:varname => start_value}: il nome della variabile con l’identificativo dei record e il valore da cui partire per i nuovi record

spss.open "data1"
spss.open "data2", :ws => :ds2
union :ds2

union :ds2, :mode => :left
union :ds2, :mode => :right
union :ds2, :mode => :union
union :ds2, :mode => :intersection
union :ds2, :mode => :difference

<<

merge¶

merge unisce le variabili di un dataset al dataset attivo in base a una chiave. I record risultanti sono tutti i record del dataset attivo uniti ai corrispondenti (rispetto alla chiave) record del secondo dataset (left outer join). Il dataset da unire deve essere stato precedentemente caricato in un’altra area di lavoro (workspace).

Parametri:

:id: l’id del dataset da unire al datset attivo

:by => varlist | {x: varlist, y: varlist}: l’elenco delle variabili che compongono la chiave o un hash con gli elenchi per ciascun dataset se i nomi sono differenti

:samevar: definisce i comportamento in caso di conflitto con i nomi di variabile:

:error: genera errore se la variabile da unire è già presente nel dataset attivo (default)

:skip: ignora eventuali variabili già presenti

:ren_x: rinomina la variabile del dataset attivo

:ren_y: rinomina la variabile del dataset che si sta unendo

:sub: sostituisce completamente la variabile già presente

:update: aggiorna i dati della variabile già presente

:upvalid: aggiorna i dati della variabile già presente solo se il nuovo dato è un dato valido

:keep => varlist: variabili del dataset che si sta unendo da includere

:drop => varlist: variabili del dataset che si sta unendo da escludere

:flag => :varname | [:varname, value] | {:varname => value}: flag che identifica i record che hanno trovato una corrispondenza sulla chiave

:nr => :varname: progressivo all’interno di ciascuna occorrenza della chiave di merge nel database attivo

:semi => false|true: non unisce nessuna variabile ma, se specificato :flag, marca i record trovati, altrimenti elimina i record non trovati

:anti => false|true: non unisce nessuna variabile ma, se specificato :flag, marca i record non trovati, altrimenti elimina i record trovati

spss.open "data1"
spss.open "comuni", :ws => :comuni
merge :comuni, by: {x: [:id_comune, :id_prov], y: [:codcdc, :codpr]}, samevar: :upvalid, flag: {:updated => 2}

spss.open "sample1", :ws => :smp1
merge :smp1, :by => :id, :semi => true

<<

semi_join¶

VERSIONE 2.5.5.105

semi_join trova i record comuni di entrambi i dataset. Se è stato specificato :flag, marca i record trovati, altrimenti elimina i record non trovati. Equivale a merge con l’opzione :semi => true.

spss.open "data1"
spss.open "sample1", :ws => :smp1
semi_join :smp1, :by => :id

<<

anti_join¶

VERSIONE 2.5.5.105

anti_join trova i record che non esistono nel secondo dataset. Se è stato specificato :flag, marca i record che non esistono nel secondo dataset, altrimenti elimina i record che sono stai trovati anche nel secondo dataset. Equivale a merge con l’opzione :anti => true.

spss.open "data1"
spss.open "sample2", :ws => :smp2
anti_join :smp2, :by => :id

<<

aggregate¶

aggregate riduce i record che hanno la stessa chiave in un unico record applicando le funzioni specificate alle variabili.

Parametri:

:key => []: un nome di variabile o un array con un elenco di variabili che costituiscono la chiave su cui aggregare i dati. Se omesso tutti i record del dataset verranno aggregati in un unico record

:mode => :replace|:add:

:replace: il dataset viene sostituito da quello aggregato (default)

:add: i dati aggregati vengono uniti ai record esistenti (aggregate+merge)

:codes => :data|:all|:levels:

:data: genera solo le combinazioni esistenti delle chiavi (default)

:all: genera tutte le combinazioni dei codici delle chiavi presenti nei dati

:levels: aggiunge anche eventuali codici etichettati non presenti nei dati

:default => value: il valore da inserire nel caso non sia presente nessun record (default: nil, ininfluente con :codes => :data)

:nr => :varname: progressivo all’interno di ciascuna chiave (solo con :mode=:add)

:ws => :name: il workspace di destinazione. Se omesso, il nuovo dataset sostituisce quello attivo

Attenzione

In caso di filtro attivo, aggregate considererà solo i record filtrati

Funzioni di aggregazione¶

aggregate accetta un blocco contenente le funzioni di aggregazione.

1) Funzioni che generano una sola variabile. Possono essere applicate una variabile per volta: function :newvarname => :oldvarname, options, oppure su un elenco di variabili: function [newvarlist] => [oldvarlist], options. Il numero delle variabili generate deve essere uguale al numero di variabili di partenza:

:n: il progressivo delle aggregazioni create
:nval: conteggia il numero di valori validi diversi di una variabile
:first: il primo valore valido di una variabile
:last: l’ultimo valore valido di una variabile
:min: il valore minimo di una variabile
:max: il valore massimo di una variabile
:count: (ponderato) senza argomenti conteggia il numero di record che vengono aggregati. Con il nome di una variabile, conteggia il numero di record con un valore valido nella variabile. Con :values considera solo i valori indicati della variabile
:miss: (ponderato) il numero di valori mancanti di una variabile
:pct: (ponderato) la percentuale dei valori indicati dal parametro :values
:avg: (ponderato) la media dei valori validi di una variabile
:sum: (ponderato) la somma dei valori di una variabile

Le funzioni count e pct accettano il parametro:

:values => []: per limitare i valori da contare, altrimenti verranno utilizzati i valori validi

2) Funzioni che generano una variabile a partire da più variabili. Hanno la forma: function :newvarname => [oldvarlist], options. Viene generata una sola variabile a partire da un elenco di più variabili. L’operazione di aggregazione viene fatta in due diversi passi: prima si effettua un calcolo su ogni record del dataset e poi si aggrega il risultato:

:vfirst: seleziona il primo valore valido di un set di variabili e poi il primo valore valido tra i diversi record
:vlast: seleziona l’ultimo valore valido di un set di variabili e poi l’ultimo valore valido tra i diversi record
:vmin: calcola il valore minimo di un set di variabili e poi calcola il valore minimo tra i record
:vmax: calcola il valore massimo di un set di variabili e poi calcola il valore massimo tra i record
:vcount: (ponderato) conteggia il numero di valori validi in un set di variabili e poi somma il valore ottenuto per ciascun record
:vmiss: (ponderato) conteggia il numero dei valori mancanti in un set di variabili e poi somma il valore ottenuto per ciascun record
:vavg: (ponderato) calcola la media dei valori validi di un set di variabili e poi calcola la media del valore ottenuto tra i record
:vsum: (ponderato) calcola la somma dei valori di un set di variabili e poi calcola la somma dei valori tra i record

La funzione vcount accetta il parametro:

:values => []: per limitare i valori da contare, altrimenti verranno utilizzati i valori validi

3) Funzioni che generano più variabili. Hanno la forma: function :newbasename => :oldvarname, options. Vengono generate più variabili a partire da una sola variabile.

:dummy: crea una variabile per ciascun valore e assegna 1 se la variabile è uguale al valore
:split: crea una variabile per ciascun valore e assegna il valore se la variabile è uguale al valore
:counts: (ponderato) crea una variabile per ciascun valore e conteggia il numero di record
:pcts: (ponderato) crea una variabile per ciascun valore e calcola la percentuale sui casi validi

Queste funzioni accettano i parametri:

:values => []: per limitare i valori da cosiderate, altrimenti verranno utilizzati tutti i valori etichettati

:sep => "": la stringa per separare l’etichetta della variabile da quella dei valori

:no_varlab => true|false: per non inserire l’etichetta della vecchia variabile nell’etichetta

:no_vallab => true|false: per non inserire l’etichetta del valore della vecchia variabile nell’etichetta

Tulle le funzioni accettano i parametri:

:label => "": per definire l’etichetta della variabile

:levels => {}: per definire l’etichette dei valori della variabile

:default => value: il valore da inserire nel caso non sia presente nessun record (default: nil, ininfluente con :codes => :data)

Le funzioni che prevedono la ponderazione accettano:

:unweight => true: per ignorare la ponderazione attiva

aggregate :key => :id_fam do
  count  :nrecords, label: "N.RECORDS"
  first  [:area, :ampc, :regio] => [:mcr, :ampc, :regio]
  nval   :nvalue_d5 => :d5
  sum    :totwgt => :peso
  avg    :meanwgt => :peso
  count  :msodd_c => :v11, :values => [8,9,10]
  pct    :msodd_p => :v11, :values => [8,9,10]
  vcount :nlinee => s(:linea_,5)
  vsum   :toteuro => s(:linea_,5)
  vcount :x7 => s(:d7_,10), values: 1
  vmax   :voto => s(:voto_,10)
  dummy  :d5_ => :d5, no_varlab: true
  split  :s5_ => :d5, values: [1,2,3,4], sep: ' '
end

aggregate :key => [:area, :sesso], mode: :add, nr: :seq do
  count  :nrecords, label: "N.RECORDS"
  sum    :totwgt => :peso
  vcount :d7 => s(:d7_,10), values: 1
  dummy  :d5_ => :d5, no_varlab: true
end

<<

stack¶

stack genera un nuovo dataset concatenando differenti set di variabili di un dataset in singole variabili.

Converte un dataset dal formato wide al formato long:

Parametri:

:keep => :varname|varlist: una stringa o simbolo oppure un array con le variabili che devono essere riportate come sono nei nuovi record. Se omesso include tutte le variabili tranne quelle che verranno concatenate.

:vars => {:varname => varlist, ...}: un hash con i set di variabili che devono essere concatenati. Le chiavi dellhash sono i nomi delle nuove variabili, mentre i valori sono gli elenchi delle variabili.

:group => {} (opzionale): un hash con la variabile che distingue i gruppi di record. Contiene le chiavi :name, :label e :levels

:ws => :name (opzionale): il workspace di destinazione. Se omesso, il nuovo dataset sostituisce quello attivo

Il dataset viene generato, ma non attivato.

stack :vars => {:d1 => s(:v1_,10)}

stack :keep => [:ser_no, :area, :sesso, :eta, :peso],
      :vars => {:d6 => s(:d6_,6), :d7 => s(:d7_,6)},
      :group => {
         :name => :bimestre,
         :label => "Bimestri 2013",
         :levels => {1 => "Gen-Feb", 2 => "Mar-Apr", 3 => "Mag-Giu", 4 => "Lug-Ago", 5=> "Set-Ott", 6 => "Nov-Dic"}
      },
      :ws => :staked

In :levels, le forme {1 => "Qt1", 2 => "Qt2", 3 => "Qt3"} e ["Qt1", "Qt2", "Qt3"] sono equivalenti, ma è necessario utilizzare un hash se si vuole generare dei codici non progressivi: {1 => "Qt1", 5 => "Qt2", 9 => "Qt3"}.

Attenzione

In caso di filtro attivo, stack considererà solo i record filtrati

<<

unstack¶

unstack genera un nuovo dataset contenente un solo record per ogni valore della chiave e affiancando gruppi ripetuti di variabili.

Converte un dataset dal formato long al formato wide:

Parametri:

:key => :varname|varlist: un nome di variabile o un array con un elenco di variabili che identificano i record del nuovo data frame

:keep => varlist: un array con un elenco di variabili che devono essere riportate come sono nei nuovi record: il loro valore viene assunto come costante rispetto alla chiave; in caso di valori differenti viene tenuto l’ultimo valore

:group => :varname|{:varname => valuelist}: il nome della variabile che identifica i gruppi da ripetere o oppure un hash con il nome della variabile e lelenco dei valori dei gruppi da generare

:vars => varlist: le variabili da ripetere per ciascun gruppo

:noprefix => false|true (opzionale): se true e :vars contiene una sola variabile, nomina le nuove variabili solo con il valore contenuto nella variabile :group (cioè quando ogni record contiene il valore di una sola variabile e :group il nome della variabile)

:labelpos => :start|:end|:none (opzionale): la posizione dell’etichetta dei gruppi all’interno dell’etichetta delle variabili ripetute

:sep => 'string' (opzionale): i caratteri che separano l’etichetta del gruppo da quella della variabile

:ws => :name (opzionale): l’ID del workspace di destinazione.

Indicando un nome di variabile in :group verranno generati tutti i gruppi presenti nei dati più eventuali altri gruppi presenti delle etichette della variabile, ma non presenti nei dati. Indicando invece un hash con il nome della variabile e l’elenco dei valori, verranno generati solo i gruppi specificati, ignorando eventuali altri valori presenti nei dati e aggiungendo eventuali altri gruppi non presenti nei dati.

Il dataset viene generato, ma non attivato.

unstack :key => :ser_no,
        :keep => [:mcr, :sesso, :eta, :titolo, :prof, :peso],
        :vars => [:v1, :v2, s(:d7,10), :v35, :v47],
        :group => :bimestre,
        :labelpos => :end,
        :sep => " - ",
        :ws => :unstacked

unstack :key => [:sample, :ser_no],
        :keep => [:mcr, :sesso, :eta, :titolo, :prof, :peso],
        :vars => [:v1, :v2, s(:d7,10), :v35, :v47],
        :group => {:quarter => [4, 5, 6]},
        :ws => :unstacked

Attenzione

In caso di filtro attivo, unstack considererà solo i record filtrati

<<

dupl¶

dupl duplica i record e li accoda al dataset.

Parametri:

:varname => value: la variabile e il valore che identifica i casi da duplicare

:id => :varname | [:varname, start_value | {:varname => start_value}: il nome della variabile con l’identificativo dei record e il valore da cui partire per i nuovi record

:flag => :varname | [:varname, value] | {:varname => value} il nome e il valore di una variabile per identificare i casi duplicati

dupl :zzz => 1, :id => [:ser_no, 1000], :flag => [:zzz, 2]

<<

swap¶

swap scambia i valori delle variabili.

Parametri:

:varname => value: la variabile e il valore che identifica i casi da trattare

:by => :varname: esegue l’operazione all’interno delle modalità della variabile

:groups => [[], []]: i gruppi di variabili

:seed => number: un seed per replicare i risultati

swap :zzz => 2, :by => :mcr, :seed => 123,
     :groups => [ [:a1, :a2, :a3, :b1, :b2, :b3, :b4],
                  s(:q18_,10),
                  :x10.to(:z15) ]

<<

diff¶

diff confronta due dataset e produce un report con le differenze trovate nella struttura, nelle variabili e nei dati. Può generare una variabile per identificare i record con dati differenti.

Parametri:

:id1: l’id del primo dataset da confrontare. Se omesso, utilizza il dataset attivo

:id2: l’id del secondo dataset da confrontare

:by => varlist | {x: varlist, y: varlist}: l’elenco delle variabili che compongono la chiave o un hash con gli elenchi per ciascun dataset se i nomi sono differenti. Se non specificato, il confronto verrà fatto record per record seguendo l’ordinamento corrente dei dataset

:keep => varlist: variabili da includere nel confronto

:drop => varlist: variabili da escludere nel confronto

:vars => varlist: variabili aggiuntive del primo dataset da listare nel report

:flag => :varname: flag che identifica i record che hanno dati differenti: verrà assegnato 1 ai record con dati differenti e 2 ai record aggiuntivi (solo se :dat è incluso negli elemnti da confrontare)

:xlsx => filename: nome del file xlsx (senza estensione) in cui salvare il report

:compare => :all|[:var, :form, :rec, :dat]: gli elenchi di elementi differenti da produrre (default :all):

:var: le differenze tra gli insiemi di variabili

:form: le differenze nei formati delle variabili

:rec: le differenze tra gli insiemi di record

:dat: le differenze nei dti dei record

diff :ds1, :ds2, :flag => :diff, :xlsx => "diff"

diff :ds1, :ds2, :by => [:id_fam, :id_comp]

diff :ds2, :by => :ser_no, :drop => [:name, :address, :city]

diff :ds2, :by => :ser_no, :xlsx => "filediff"

*** Diff: compare dataset <ds1> with dataset <ds2> ***

Datasets
+---------+------------+--------------+
| dataset | n. records | n. variables |
+---------+------------+--------------+
|   ds1   |     16     |      10      |
|   ds2   |     19     |      9       |
+---------+------------+--------------+

Variables diff
+---------+----+----------------------+
| dataset | n. | additional variables |
+---------+----+----------------------+
|   ds1   | 2  | eta, etaq            |
|   ds2   | 1  | d1                   |
+---------+----+----------------------+

Formats diff
+---+---------+--------+-------+-----+-----+-----+-----+-----+-----+----------------------------+----------------+
| # | varname |      type      |   size    |   ndec    |   label   |                   levels                    |
+---+---------+--------+-------+-----+-----+-----+-----+-----+-----+----------------------------+----------------+
|   |         |  ds1   |  ds2  | ds1 | ds2 | ds1 | ds2 | ds1 | ds2 |            ds1             |      ds2       |
+---+---------+--------+-------+-----+-----+-----+-----+-----+-----+----------------------------+----------------+
| 1 | sesso   |        |       |     |     |     |     |     |     | 1=>"Maschio", 2=>"Femmina" | 1=>"M", 2=>"F" |
| 2 | area    |        |       |  1  |  2  |     |     |     |     |                            |                |
| 3 | d5      | single | float |  1  |  4  |  0  |  1  |     |     |                            |                |
| 4 | peso    |        |       |     |     |     |     |     | IPF |                            |                |
+---+---------+--------+-------+-----+-----+-----+-----+-----+-----+----------------------------+----------------+

Records diff
+---------+----+--------+--------------------+
| dataset | n. |   by   | additional records |
+---------+----+--------+--------------------+
|   ds1   | 1  | ser_no | 91                 |
|   ds2   | 4  | ser_no | 220; 252; 286; 298 |
+---------+----+--------+--------------------+

Data diff
+---+------+--------+-----+-----+-----+-----+-----+-----+----------+---------+
| # | nrec | ser_no |   sesso   |   area    |    d5     |        str2        |
+---+------+--------+-----+-----+-----+-----+-----+-----+----------+---------+
|   | ds1  |  ds1   | ds1 | ds2 | ds1 | ds2 | ds1 | ds2 |   ds1    |   ds2   |
+---+------+--------+-----+-----+-----+-----+-----+-----+----------+---------+
| 1 |    8 |      9 |     |     |     |     |  .  |  4  |          |         |
| 2 |    5 |     29 |  1  |  2  |  1  |  4  |     |     |          |         |
| 3 |    9 |     56 |     |     |     |     |     |     | AGAZZANO | AGAZANO |
| 4 |   15 |     84 |     |     |     |     |  2  |  .  |          |         |
| 5 |   12 |    194 |     |     |     |     |     |     |  ALTINO  | altino  |
+---+------+--------+-----+-----+-----+-----+-----+-----+----------+---------+

filediff.xlsx: