nsmcp::AccessRecordStoreSQLite method ingest (public)

 <instance of nsmcp::AccessRecordStoreSQLite> ingest fid file \
    begin end tuples

Defined in /usr/local/ns/tcl/nsmcp/log-traffic-record-store.tcl

Parameters:

fid (required)

file (required)

begin (required)

end (required)

tuples (required)

Testcases:

No testcase defined.

Source code:

if {[${:db} scalar {SELECT count(*) FROM nsmcp_records.ranges WHERE fid=$fid}]>=4096} {error "record-store-range-limit"}
set f [open [dict get $file path] rb]
try {seek $f [expr {max(0,$end-64)}]; set anchor [ns_crypto::md string -digest sha256 -binary -- [read $f [expr {min(64,$end)}]]]} finally {close $f}
set stamp [dict get $file mtime]; set now [clock seconds]
set dropping [expr {[dict exists $file dropping] ? [dict get $file dropping] : 0}]
${:db} transaction {
    if {![${:db} scalar {SELECT count(*) FROM nsmcp_records.files WHERE fid=$fid}]} {error "record-store-generation-changed"}
    if {[llength $tuples]} {
        ${:db} execute {DELETE FROM temp.nsmcp_ingest_batch}
        ${:db} execute "INSERT INTO temp.nsmcp_ingest_batch VALUES [join $tuples ,]"
        ${:db} execute {DELETE FROM temp.nsmcp_ingest_batch WHERE EXISTS(SELECT 1 FROM nsmcp_records.rows r WHERE r.fid=nsmcp_ingest_batch.fid AND r.off=nsmcp_ingest_batch.off);
            INSERT INTO nsmcp_records.rows SELECT * FROM temp.nsmcp_ingest_batch}
        :rollBatch
        :observeBatch
    }
    if {[dict size ${:peers}]} {
        set values {}; dict for {key data} ${:peers} {
            lassign $data address seen
            lappend values "(X'$key',[${:db} quote $address],[${:db} quote $seen])"
        }
        ${:db} execute "INSERT INTO nsmcp_records.peer_addresses VALUES [join $values ,] ON CONFLICT(k) DO UPDATE SET address=CASE WHEN excluded.seen>=seen THEN excluded.address ELSE address END,seen=max(seen,excluded.seen)"
    }
    set lo $begin; set hi $end
    foreach span [${:db} execute {SELECT lo,hi,anchor FROM nsmcp_records.ranges WHERE fid=$fid AND lo<=$end AND hi>=$begin}] {
        set lo [expr {min($lo,[dict get $span lo])}]
        if {[dict get $span hi]>$hi} {set hi [dict get $span hi]; set anchor [dict get $span anchor]}
    }
    ${:db} execute {DELETE FROM nsmcp_records.ranges WHERE fid=$fid AND lo<=$end AND hi>=$begin;
        INSERT INTO nsmcp_records.ranges VALUES($fid,$lo,$hi,$anchor);
        UPDATE nsmcp_records.files SET dropping=CASE WHEN $end>=high THEN $dropping ELSE dropping END,stamp=CASE WHEN $end>=high THEN $stamp ELSE stamp END,high=max(high,$end),touched=$now WHERE fid=$fid}
    if {[:diskBytes]>[dict get ${:settings} maxBytes]} {error "record-store-disk-limit"}
}
set :peers {}

XQL Not present:

Generic, PostgreSQL, Oracle