Interim while bringing sqlc in

internal/domain64/Makefile

@@ -0,0 +1,8 @@
+clean:
+	rm -rf db
+	
+generate: clean
+	sqlc generate
+
+test:
+	go test *.go

internal/domain64/database.go

@@ -0,0 +1,40 @@
+package domain64
+
+import (
+	"database/sql"
+	"sync"
+
+	"github.com/jpillora/go-tld"
+)
+
+type Domain64Map struct {
+	mu      sync.Mutex
+	m       map[string]int
+	DB      *sql.DB
+	Flushed bool
+}
+
+// Just use the D64 values.
+// TLD :: 0-255
+// TLD.Domain :: FF:FFFFFF or some range of ints
+// TLD.DOMAIN.SUBDOMAIN :: FF:FFFFFF:FF (bigger ints)
+// now it is just a map
+// https://stackoverflow.com/questions/40568759/sqlite-query-integer-field-based-on-a-bit
+
+func NewDomain64Map(db *sql.DB) (*Domain64Map, error) {
+	d64m := &Domain64Map{}
+	d64m.DB = db
+	d64m.Flushed = true
+	// Init the tables if a DB pointer is passed in.
+	return d64m, nil
+}
+
+func (d64m *Domain64Map) Insert(url string) {
+	_, err := tld.Parse(url)
+	if err != nil {
+		// TODO
+		panic(err)
+	}
+	// If we have this TLD, return the value for it.
+
+}

internal/domain64/database_test.go

@@ -0,0 +1,41 @@
+package domain64
+
+import (
+	"context"
+	"database/sql"
+	_ "embed"
+	"testing"
+
+	_ "modernc.org/sqlite"
+)
+
+//go:embed schema.sql
+var ddl string
+
+func setup() *sql.DB {
+	ctx := context.Background()
+
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		// TODO
+		panic(err)
+	}
+
+	// create tables
+	if _, err := db.ExecContext(ctx, ddl); err != nil {
+		panic(err)
+	}
+	return db
+}
+
+func TestNewDomain64Map(t *testing.T) {
+	db := setup()
+	M, err := NewDomain64Map(db)
+	if err != nil {
+		// TODO
+		t.Error(err)
+	}
+	if M.DB == nil {
+		t.Error("DB should not be nil")
+	}
+}

internal/domain64/db.go

@@ -0,0 +1,31 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.30.0
+
+package domain64
+
+import (
+	"context"
+	"database/sql"
+)
+
+type DBTX interface {
+	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
+	PrepareContext(context.Context, string) (*sql.Stmt, error)
+	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
+	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
+}
+
+func New(db DBTX) *Queries {
+	return &Queries{db: db}
+}
+
+type Queries struct {
+	db DBTX
+}
+
+func (q *Queries) WithTx(tx *sql.Tx) *Queries {
+	return &Queries{
+		db: tx,
+	}
+}

internal/domain64/domain64.go

@@ -20,13 +20,31 @@ packet-beta
 40-63: "FFFFFF | Path"
 ```
 */
-func (d64 *Domain64) AsInt64() int64 {
+const SHIFT_TLD = (64 - 8)
+const SHIFT_DOMAIN = (64 - (8 + 24))
+const SHIFT_SUBDOMAIN = (64 - (8 + 24 + 8))
+const SHIFT_PATH = (64 - (8 + 24 + 8 + 24))
+
+const MASK_TLD = 0xFF0000000000000
+const MASK_DOMAIN = 0x00FFFFFF00000000
+const MASK_SUBDOMAIN = 0x00000000FF000000
+const MASK_PATH = 0x0000000000FFFFFF
+
+func (d64 Domain64) ToInt64() int64 {
 	var result int64 = 0
-	result = result | (int64(d64.TLD) << (64 - 8))
-	result = result | (int64(d64.Domain) << (64 - (8 + 24)))
-	result = result | (int64(d64.Subdomain) << (64 - (8 + 24 + 8)))
-	result = result | (int64(d64.Path) << (64 - (8 + 24 + 8 + 24)))
+	result = result | (int64(d64.TLD) << SHIFT_TLD)
+	result = result | (int64(d64.Domain) << SHIFT_DOMAIN)
+	result = result | (int64(d64.Subdomain) << SHIFT_SUBDOMAIN)
+	result = result | (int64(d64.Path) << SHIFT_PATH)
 	return result
 }
 
-// https://gobyexample.com/testing-and-benchmarking
+func IntToDomain64(i int64) Domain64 {
+	d64 := Domain64{}
+
+	d64.TLD = uint8((i & MASK_TLD) >> SHIFT_TLD)
+	d64.Domain = uint16((i & MASK_DOMAIN) >> SHIFT_DOMAIN)
+	d64.Subdomain = uint8((i & MASK_SUBDOMAIN) >> SHIFT_SUBDOMAIN)
+	d64.Path = uint16(i & MASK_PATH)
+	return d64
+}

internal/domain64/domain64_test.go

@@ -0,0 +1,45 @@
+package domain64
+
+import (
+	"testing"
+)
+
+// https://gobyexample.com/testing-and-benchmarking
+
+// For testing the conversion between a Domain64 struct
+// and the int64 representation of that domain.
+var tests = []struct {
+	d64   Domain64
+	asInt int64
+}{
+	{
+		Domain64{
+			TLD:       1,
+			Domain:    1,
+			Subdomain: 1,
+			Path:      1,
+		}, 72057598349672449},
+	{
+		Domain64{
+			TLD:       2,
+			Domain:    1,
+			Subdomain: 1,
+			Path:      0,
+		}, 144115192387600384},
+}
+
+func TestDomain64ToInt(t *testing.T) {
+	for _, tt := range tests {
+		if tt.d64.ToInt64() != tt.asInt {
+			t.Errorf("%q != %d Domain64 did not convert", tt.d64, tt.asInt)
+		}
+	}
+}
+
+func TestIntToDomain64(t *testing.T) {
+	for _, tt := range tests {
+		if IntToDomain64(tt.asInt) != tt.d64 {
+			t.Errorf("%d != %q int64 did not convert", tt.asInt, tt.d64)
+		}
+	}
+}

internal/domain64/query.sql

@@ -0,0 +1,12 @@
+-- name: InsertDomain64 :exec
+INSERT INTO d64 
+  (url, d64, tld_id, domain_id, subdomain_id, path_id) 
+  VALUES 
+  (?, ?, ?, ?, ?, ?);
+
+-- name: GetTLD :one
+SELECT id from domain64
+  WHERE tld_id = ?
+
+-- name: CountTLD :one
+SELECT COUNT(*) FROM domain64 WHERE tld_id = ?;

internal/domain64/schema.sql

@@ -0,0 +1,9 @@
+CREATE TABLE domain64 (
+  id INT PRIMARY KEY,
+  url TEXT,
+  d64 BIGINT,
+  tld_id INT,
+  domain_id INT,
+  subdomain_id INT,
+  path_id INT
+)

internal/domain64/sqlc.yaml

@@ -0,0 +1,9 @@
+version: "2"
+sql:
+  - engine: "sqlite"
+    queries: "query.sql"
+    schema: "schema.sql"
+    gen:
+      go:
+        package: "db"
+        out: "db"