Visualizzazione post con etichetta Sqlite. Mostra tutti i post
Visualizzazione post con etichetta Sqlite. Mostra tutti i post

venerdì 4 marzo 2022

Recupero Sticky Notes

Un collega mi telefona dicendo di avere perso dati importanti salvati nei PostIt virtuali di Windows 10 con una applicazione chiamata Sticky Notes....francamente non sapevo nemmeno che Windows avesse una applicazione di sistema di questo tipo ma quando mi dice che il file dove i dati vengono salvati e' chiamato plum.sqlite gli dico che provo a dare un'occhiata (ho lavorato su qualche progetto usando Sqlite)


In particolare la nota incriminata non risulta essere stata cancellata ma a schermo presenta una serie di ++++++++. Aprendo il file con effettivamante nella tabella note si vedono solo 3 righe di cui una con soli segno +. Il controllo di integrita' del database e' passato senza problemi quindi non ci sono corruzioni di indici

Stavo rinunciando quando mi sono ricordato che i database di solito non cancellano i dati direttamente ma solo dopo un esplicito comando ...ho provato a fare un export in csv da DB Browser for Sqlite per vedere se oltre ai dati mostrati venivano esportate anche le righe cancellate...bingo.. il file di esportazione presentava i dati cancellati in formato umanamente leggibile




mercoledì 31 gennaio 2018

Esempio mini blockchain

Uno stupido esempio di blockchain senza peer to peer e senza POW...solo per fare vedere come sono collegati i vari record e come si valida un blocco


------------------------------------------------------------------------
import sqlite3, hashlib, time

conn = sqlite3.connect("blockchain.txt")
c =conn.cursor()
c.execute("CREATE TABLE IF NOT EXISTS blocks (id integer PRIMARY KEY AUTOINCREMENT, tempo integer NOT NULL,data text NOT NULL, hash text NOT NULL, precedentehash text NOT NULL)")
c.execute("DELETE FROM blocks")

#INSERISCE IL PRIMO RECORD 
#il precedenteh puo' essere impostato come si desidera
indice = 0
precedentehash = "0"
millis = int(round(time.time() * 1000))
data = "Luca"
hash = hashlib.sha256(str(indice) + precedentehash + str(millis) + data)
hex_dig = hash.hexdigest()

query = "INSERT INTO blocks (tempo,data,hash,precedentehash) VALUES ("+str(millis)+",'"+data+"','" + hex_dig+"','" + precedentehash + "')"

print query

c.execute(query)
conn.commit()

# SECONDO RECORD

c.execute("SELECT * FROM blocks ORDER BY id DESC LIMIT 1")
row =  c.fetchone()
precedentehash = row[3]
indice = row[0]+1
millis = int(round(time.time() * 1000))
data ="Innocenti"
hash = hashlib.sha256(str(indice) + precedentehash + str(millis) + data)
hex_dig = hash.hexdigest()
query = "INSERT INTO blocks (tempo,data,hash,precedentehash) VALUES ("+str(millis)+",'"+data+"','" + hex_dig+"','" + precedentehash + "')"
print query

c.execute(query)
conn.commit()


# TERZO RECORD

c.execute("SELECT * FROM blocks ORDER BY id DESC LIMIT 1")
row =  c.fetchone()
precedentehash = row[3]
indice = row[0]+1

millis = int(round(time.time() * 1000))
data ="Firenze"
hash = hashlib.sha256(str(indice) + precedentehash + str(millis) + data)
hex_dig = hash.hexdigest()
query = "INSERT INTO blocks (tempo,data,hash,precedentehash) VALUES ("+str(millis)+",'"+data+"','" + hex_dig+"','" + precedentehash + "')"
print query

c.execute(query)
conn.commit()

#un blocco e' valido se
# l'indice e' maggiore del blocco precedente
# il precedenteh del blocco in esame e' uguale all'hash del record precedente
# l'hash del blocco e' conforme
print "---------------------------------------------"
#controlla l'integrita' del blocco 3
c.execute("SELECT * FROM blocks WHERE id=3")
c3 = c.fetchone()
c.execute("SELECT * FROM blocks WHERE id=2")
c2 = c.fetchone()

if c2[0] ==(c3[0]-1):
    print "Indice OK"
if c2[3] == c3[4]:
    print "HASH precedente Corretto"
    
precedentehash = c3[4]
millis = c3[1]
data = c3[2]
indice = c3[0]
hash = hashlib.sha256(str(indice) + precedentehash + str(millis) + data)
hex_dig = hash.hexdigest()

if c3[3] == hex_dig:
    print "Blocco corretto"

   
print "---------------------------------------------"

# mostra tutto il DB
c.execute("SELECT * FROM blocks")
rows = c.fetchall()
for r in rows:
    print(r)

conn.close()

martedì 14 febbraio 2017

SMS Server su Android

Se con i vecchi Nokia era molto semplice creare un SMS server, con Android cio' non e' possibile perche' i dati sono contenuti in una sezione del disco non accessbile in modo immediato e non esiste la possibilita' di default di creare un backup.
Alcuni hanno sviluppati applicazioni Android che leggono il database degli SMS e li reinviano via mail ma la soluzione non e' molto elegante e flessibile...l'ideale e' accedere via ADB

Per prima cosa pero' e' necessario effettuare il root del dispositivo (nel mio caso un Moto E)



i dati degli SMS sono contenuti nel file  /data/data/com.android.providers.telephony/databases/mmssms.db 
(e' un database Sqlite) che risulta essere accessibile solo a root....il gioco e' quindi copiarlo in una porzione del disco raggiungibile via adb pull come /data/local/tmp (da creare a mano via adb shell una volta per tutte).

----------------------------------
adb shell "su -c 'rm /data/local/tmp/mmssms.db'"

adb shell "su -c 'cp /data/data/com.android.providers.telephony/databases/mmssms.db /data/local/tmp'"
adb shell "su -c 'chmod 755 /data/local/tmp/mmssms.db'"
adb pull /data/local/tmp/mmssms.db
----------------------------------

Una volta ottenuto il file sul proprio computer gran parte del lavoro e' fatto.
Usando DB Browser for SQLite (per comodita') si osservano tutte le tabelle


il mio interesse e' quello di avere in uscita in CSV dei soli dati degli SMS. 

A questo punto mi interessa estrarre solo i campi body e date_sent e si puo' fare con il seguente script bash

------------------
sqlite3 mmssms.db << EOF
.mode csv
.headers on
.separator ";"
.output sms2.csv
select body,datetime(date_sent/1000, 'unixepoch','localtime') from sms;
.exit
EOF
------------------




venerdì 27 settembre 2013

Sqlite in Php per uso Web



Per poter effettuare delle operazioni di Insert/Update/Delete su database Sqlite gestito da interfaccia Web e' necessario che il file di database abbia i permessi corretti

Non e' sufficiente settare a 777 i permessi del file .db ma deve essere anche impostato come proprietario del file l'utente apache (che su Debian e' www-data) con il seguente comando (attenzione ai punti)
----------------------
chown www-data. . 
----------------------

in caso contrario degli script sintatticamente corretti non funzioneranno

lunedì 16 settembre 2013

Sqlite e Php

Un metodo semplice per avere un database su un sito Web senza utilizzare un sql server e' quello di impiegare sqlite (che non e' basato su un motore sql ma su semplici file)

Per l'installazione si procede semplicemente con

apt-get install php5-sqlite


Di seguito un breve codice che crea il file di database (rfid.db), crea una tabella all'interno, la popola ed effettua una select rilasciando poi l'oggetto db
---------------------------
<?php
$db = new PDO('sqlite:rfid.db');
$db->exec("CREATE TABLE rfid (rfid TEXT,token TEXT)");  
$db->exec("INSERT INTO rfid (rfid, token) VALUES ('12345', 'abcdef');");
$results = $db->query('SELECT * FROM rfid');
foreach($results as $row)
{
print $row['rfid']."-".$row['token']."<br>";
}
$db = NULL;
?>

lunedì 1 luglio 2013

SQlite in Python

Un esempio su come usare Sqlite in Python

Per installare le librerie di Sqlite si digita

apt-get install python-sqlite

--------------------------------------------------------
#!/usr/bin/python
# -*- coding: utf-8 -*-

import sqlite3 as lite
import sys

con = lite.connect('birra.db')

with con:
    
cur = con.cursor()    
cur.execute("DROP TABLE IF EXISTS birra")
cur.execute("CREATE TABLE birra(Rifd TEXT, Gratis INT)")
cur.execute("INSERT INTO birra VALUES('12345',1)")
cur.execute("SELECT * FROM birra")
while True:
row = cur.fetchone()

if row == None:
break

print row[0], row[1]
if row[1] == 1: 
print "Birra gratis"
else:
print "Birra da pagare"

cur.execute("UPDATE birra SET Gratis=0 WHERE Rifd='12345'")
cur.execute("SELECT * FROM birra")
while True:
row = cur.fetchone()

if row == None:
break

print row[0], row[1]
if row[1] == 1: 
print "Birra gratis"
else:
print "Birra da pagare"

lunedì 8 aprile 2013

Sqlite Manager come estensione di Firefox

In ambiti in cui non e' possibile installare programmi puo' risultare utile utilizzare l'estensione SQLite Manager

L'installazione e' quella comune a tutti i plugin di Firefox e l'uso e' sostanzialmente immediato con la possibilita' di caricare il file ed eseguire query


venerdì 29 marzo 2013

Sqlite Manager su Windows

Per gestire i file generati da Sqlite su Windows puo' essere utile usare il programma che si scarica gratuitamente da questo link


venerdì 25 gennaio 2013

SQLite in Qt

In questo post verra' presentato un esempio di utilizzo di Qt con Sqlite

Le librerie Qr hanno gia' al loro interno il supporto per Sqlite per cui non e' necessaria l'installazione di nessun componente aggiuntivo
Per prima cosa si deve modificare il file .pro per includere il supporto sql (come evidenziato in giallo nel listato sottostante)



sql.pro
--------------------------------------------

QT       += core
QT       += sql
QT       -= gui

TARGET = sql
CONFIG   += console
CONFIG   -= app_bundle

TEMPLATE = app


SOURCES += main.cpp

--------------------------------------------

L'esempio effettua tre query
Nella prima viene creata una tabella inserendo tre righe
Nella seconda viene effettuata una SELECT senza vincoli
Nella terza viene effettuata una SELECT condizionata da un WHERE
Il codice e' sostanzialmente autoesplicativo.L'unica cosa da sottolineare e' che in QtCreator sotto Windows si dove dichiarare un include <QtSql> mentre in Linux deve essere modificato in <QtSql\QtSql>

main.cpp
--------------------------------------------

#include <QtCore/QCoreApplication>
#include <Qtsql>
//per Linux si deve sostituire la riga precedente con
//#include <QtSql/QtSql>

#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
        db.setDatabaseName("c:/punteggio.db");
        if (!db.open()) {

            return false;
        }

        QSqlQuery query;

        query.exec("create table punteggio (id int primary key, "
                                         "nome varchar(20), "
                                         "punti int)");

        query.exec("insert into punteggio values(0, 'Luca', 2)");
        query.exec("insert into punteggio values(1, 'Federico', 102)");
        query.exec("insert into punteggio values(2, 'Alessio', 15)");


        QSqlQuery query2;
        query2.prepare( "SELECT * FROM punteggio" );
        if( !query2.exec() )
        {
            qDebug() << "Errore sulla query";

        }
        while( query2.next() )
        {
            int punti = query2.value(2).toInt();
            QString nome = query2.value(1).toString();
            qDebug() << nome << " " << punti << endl;
        }

        // SELECT CONDIZIONATA DA WHERE
        QSqlQuery query3;
        query3.prepare( "SELECT * FROM punteggio WHERE punti > ?" );
        query3.bindValue(":punti",20);

        if( !query3.exec() )
        {
            qDebug() << "Errore sulla query";

        }
        while( query3.next() )
        {
            int punti = query3.value(2).toInt();
            QString nome = query3.value(1).toString();
            qDebug() << nome << " " << punti << endl;
        }


    return a.exec();
}


--------------------------------------------

asd

Sqliteman in Debian

Al contrario di Ubuntu o di altre distro, non esiste un pacchetto gia' pronto per installare Sqliteman in Debian testing


La soluzione e' scaricare il pacchetto del sorgente del programma da Sourceforge (al momento la versione piu' recente e' sqliteman-1.2.2.tar.bz2)

dopo aver spacchettato l'archivio si entra nella directory e si procede con i seguenti comandi

apt-get install cmake
apt-get install libqscintilla2-8 libqscintilla2-dev
apt-get install sqlite3

cmake . (notare il punto dopo cmake)
make
make install


giovedì 29 novembre 2012

Utilizzo SQLite con C

Per terminare la carrellata dell'utilizzo di SQLite (gia' visto qui e qui) si vede l'utilizzo con C sia su Linux che su Windows (mediante Dev-C++ con il DevPack SQLite). Verrano ripetute le operazioni (piu' o meno) gia' eseguite con gli altri linguaggi

Nel progetto Dev-C++ si devono impostare l'utlizzo della libreria SQLite come indicato nella figura sottostante


per utilizzare il programma mediante Dev-C++ e' necessario che la libreria libsqlite3-0.dll sia accessibile (nella stessa directory dove viene ubicato l'eseguibile oppure in una directory di sistema di Windows...attenzione che dal sito di SQLite si scarica una dll nominata sqlite3.dll che non funziona all'interno di Dev-C++..si deve impiegare quella inserita nel DevPack)

Altrimenti dentro Linux il file puo' essere compilato con la seguente riga di comando
gcc -o sqlite_test sqlite_test.c  -Wall -O3 -lsqlite3

di seguito viene riportato il codice sorgente che e' sostanzialmente autoesplicativo in quanto effettua delle exec di comandi SQL
------------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>


int main(int argc, char **argv){
sqlite3 *db;
char *zErrMsg = 0;
int rc;

rc = sqlite3_open("utenti.db", &db);
if (rc == SQLITE_OK)
{
rc = sqlite3_exec(db, "CREATE TABLE IF NOT EXISTS users  (Id INTEGER PRIMARY KEY,username TEXT, password TEXT, email TEXT)", NULL, 0, &zErrMsg);
if (rc != SQLITE_OK) fprintf(stderr, "SQL error: %s\n", zErrMsg);

rc = sqlite3_exec(db, "INSERT INTO users VALUES (NULL,\"luca\",\"password\",\"lucainnoc@gmail.com\")", NULL, 0, &zErrMsg);
if (rc != SQLITE_OK) fprintf(stderr, "SQL error: %s\n", zErrMsg);
rc = sqlite3_exec(db, "INSERT INTO users VALUES (NULL,\"chiara\",\"password\",\"chiara@gmail.com\")", NULL, 0, &zErrMsg);
if (rc != SQLITE_OK) fprintf(stderr, "SQL error: %s\n", zErrMsg);

sqlite3_stmt *stmt;
rc = sqlite3_prepare_v2(db, "SELECT * FROM users", -1, &stmt, 0);
if (rc == SQLITE_OK) {
int nCols = sqlite3_column_count(stmt);
if (nCols)
{
for (int nCol = 0; nCol < nCols; nCol++)
printf("%s\t", sqlite3_column_name(stmt, nCol));
printf("\n");
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW)
for (int nCol = 0; nCol < nCols; nCol++)
printf("%s\t", sqlite3_column_text(stmt, nCol));
printf("\n");
}
sqlite3_finalize(stmt);
}

rc = sqlite3_exec(db, "DELETE FROM users", NULL, 0, &zErrMsg);
if (rc != SQLITE_OK) fprintf(stderr, "SQL error: %s\n", zErrMsg);

sqlite3_close(db);
} else {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return 1;
}
return 0;

}

mercoledì 28 novembre 2012

Utilizzo di SQLite con Android

Riprendendo il precedente post qui verra' mostrato come usare SQLite all'interno di Android partendo da questo esempio

Per prima cosa si deve scrivere una classe di helper in cui sono identificate la struttura del Db e le operazioni da eseguire...per semplicita' viene utilizzata la struttura gia' vista nello script Python

-----------------------------------------------------------------------

package com.example.sqlite;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;

public class database {
SQLiteDatabase mDb;
     DbHelper mDbHelper;
     Context mContext;
     private static final String DB_NAME="users";//nome del db
     private static final int DB_VERSION=1; //numero del db
     
     public database(Context ctx){
             mContext=ctx;
             mDbHelper=new DbHelper(ctx, DB_NAME, null, DB_VERSION);        
     }
     
     public void open(){  
             mDb=mDbHelper.getWritableDatabase();
             
     }
     
     public void close(){ 
             mDb.close();
     }
     
     public void insertUtente(String name,String password, String email){ // genera l'INSERT
             ContentValues cv=new ContentValues();
             cv.put(UsersMetaData.USERNAME_KEY, name);
             cv.put(UsersMetaData.PASSWORD_KEY, password);
             cv.put(UsersMetaData.EMAIL_KEY,email);
             mDb.insert(UsersMetaData.USERS_TABLE, null, cv);
     }
     
     public void deleteUtente(String id) {
         mDb.delete(UsersMetaData.USERS_TABLE, UsersMetaData.ID + "=" + id, null);
     }

    
     public Cursor fetchUtenti(){ //genera la SELECT
             return mDb.query(UsersMetaData.USERS_TABLE, null,null,null,null,null,null);               
     }

     public class UsersMetaData {  // variabili
             static final String USERS_TABLE = "users";
             static final String ID = "_id";
             static final String USERNAME_KEY = "username";
             static final String PASSWORD_KEY = "password";
             static final String EMAIL_KEY = "email";
     }

     private static final String USERS_TABLE_CREATE = "CREATE TABLE IF NOT EXISTS "  //CREATE TABLE
                     + UsersMetaData.USERS_TABLE + " (" 
                     + UsersMetaData.ID+ " integer primary key autoincrement, "
                     + UsersMetaData.USERNAME_KEY + " text not null, "
                     + UsersMetaData.PASSWORD_KEY + " text not null, "
                     + UsersMetaData.EMAIL_KEY + " text not null);";

     private class DbHelper extends SQLiteOpenHelper { //helper

             public DbHelper(Context context, String name, CursorFactory factory,int version) {
                     super(context, name, factory, version);
             }

             public void onCreate(SQLiteDatabase _db) { //solo quando il db viene creato, creiamo la tabella
                     _db.execSQL(USERS_TABLE_CREATE);
             }

             public void onUpgrade(SQLiteDatabase _db, int oldVersion, int newVersion) {

             }

     }
}
---------------------------------------------------------

a questo punto si puo' procedere utilizzando la classe helper 
il codice e' sostanzialmente autoesplicativo
----------------------------------------------------------
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
database utenti =new database(getApplicationContext());
utenti.open();
utenti.insertUtente("luca", "password", "lucainnoc@gmail.com");
utenti.insertUtente("chiara", "password", "chiara@gmail.com");
        
Cursor c=utenti.fetchUtenti(); // query
        
int usernameCol=c.getColumnIndex(UsersMetaData.USERNAME_KEY);  //indici delle colonne
int passwordCol=c.getColumnIndex(UsersMetaData.PASSWORD_KEY);
int mailCol=c.getColumnIndex(UsersMetaData.EMAIL_KEY);
        
       if(c.moveToFirst()){  
            do {
                Log.d("select",c.getString(usernameCol)+" "+c.getString(passwordCol)+" "+c.getString(mailCol));                    
                    } while (c.moveToNext());//iteriamo al prossimo elemento
        }
    
utenti.deleteUtente("1");
        
if(c.moveToFirst()){  
        do {
            Log.d("select",c.getString(usernameCol)+" "+c.getString(passwordCol)+" "+c.getString(mailCol));                    
             } while (c.moveToNext());//iteriamo al prossimo elemento
    }
utenti.close();
        

Utilizzo di base di Sqlite con Python

Sqlite e' un database basato su un unico file che ha bindings in numerosi linguaggi; l'aspetto piu' interessanto dell'impiego con Python e' quello di essere inserito all'interno del linguaggio (per lo meno dalla versione 2.5 e superiori) e per questo motivo non e' necessario utilizzare librerie esterne per il suo impiego

Di seguito un esempio delle operazioni base effettuate impiegando Python...attenzione al commit finale (Sqlite ammette le transazioni atomiche)
-----------------------------------------------------------------

from sqlite3 import dbapi2 as sqlite
con = sqlite.connect('utenti.db')
cur = con.cursor()

#crea una tabella con un indice ad autoincremento
cur.execute('CREATE TABLE users (Id INTEGER PRIMARY KEY,username TEXT, password TEXT, email TEXT)')

#effettua alcuni inserimenti
# NULL serve per l'indice ad autoincremento
cur.execute('INSERT INTO users VALUES (NULL,"luca","password","lucainnoc@gmail.com")')
cur.execute('INSERT INTO users VALUES (NULL,"chiara","password","chiara@gmail.com")')
print "-----------------------"

#estrae tutte le righe
cur.execute('SELECT * FROM users')
for row in cur:
    print row
    print row[0]
    print row[1]
    print row[2]
    print "-----------------------"

#estrae solo una riga
nome = "luca"
cur.execute("SELECT * FROM users WHERE username=:username",  {"username": nome})
for row in cur:
    print row
print "-----------------------"

#cancella una riga
cur.execute("DELETE FROM users WHERE username=:username",  {"username": nome})

cur.execute('SELECT * FROM users')
for row in cur:
    print row
print "-----------------------"

#cancella la tabella
cur.execute('DROP TABLE users')
con.commit()
cur.close()

Debugger integrato ESP32S3

Aggiornamento In realta' il Jtag USB funziona anche sui moduli cinesi Il problema risiede  nell'ID USB della porta Jtag. Nel modulo...