[g175] graph/db: v2 columns and v2 node CRUD

graph/builder.go

@@ -874,7 +874,7 @@ func (b *Builder) assertNodeAnnFreshness(ctx context.Context, node route.Vertex,
 	// node announcements, we will ignore such nodes. If we do know about
 	// this node, check that this update brings info newer than what we
 	// already have.
-	lastUpdate, exists, err := b.cfg.Graph.HasNode(ctx, node)
+	lastUpdate, exists, err := b.cfg.Graph.HasV1Node(ctx, node)
 	if err != nil {
 		return fmt.Errorf("unable to query for the "+
 			"existence of node: %w", err)

graph/db/graph.go

@@ -664,10 +664,19 @@ func (c *ChannelGraph) FetchNode(ctx context.Context,
 	return c.db.FetchNode(ctx, nodePub)
 }
 
-// HasNode determines if the graph has a vertex identified by the target node.
-func (c *ChannelGraph) HasNode(ctx context.Context,
+// HasV1Node determines if the graph has a vertex identified by the target node
+// in the V1 graph.
+func (c *ChannelGraph) HasV1Node(ctx context.Context,
 	nodePub [33]byte) (time.Time, bool, error) {
 
+	return c.db.HasV1Node(ctx, nodePub)
+}
+
+// HasNode determines if the graph has a vertex identified by the target node
+// in the V1 graph.
+func (c *ChannelGraph) HasNode(ctx context.Context, nodePub [33]byte) (bool,
+	error) {
+
 	return c.db.HasNode(ctx, nodePub)
 }
 

graph/db/graph_test.go

@@ -138,7 +138,7 @@ func TestNodeInsertionAndDeletion(t *testing.T) {
 	dbNode, err := graph.FetchNode(ctx, testPub)
 	require.NoError(t, err, "unable to locate node")
 
-	_, exists, err := graph.HasNode(ctx, dbNode.PubKeyBytes)
+	exists, err := graph.HasNode(ctx, dbNode.PubKeyBytes)
 	require.NoError(t, err)
 	require.True(t, exists)
 
@@ -309,7 +309,7 @@ func TestPartialNode(t *testing.T) {
 	dbNode2, err := graph.FetchNode(ctx, pubKey2)
 	require.NoError(t, err)
 
-	_, exists, err := graph.HasNode(ctx, dbNode1.PubKeyBytes)
+	exists, err := graph.HasNode(ctx, dbNode1.PubKeyBytes)
 	require.NoError(t, err)
 	require.True(t, exists)
 
@@ -318,7 +318,7 @@ func TestPartialNode(t *testing.T) {
 	expectedNode1 := models.NewV1ShellNode(pubKey1)
 	compareNodes(t, expectedNode1, dbNode1)
 
-	_, exists, err = graph.HasNode(ctx, dbNode2.PubKeyBytes)
+	exists, err = graph.HasNode(ctx, dbNode2.PubKeyBytes)
 	require.NoError(t, err)
 	require.True(t, exists)
 

graph/db/interfaces.go

@@ -119,12 +119,19 @@ type Store interface { //nolint:interfacebloat
 	FetchNode(ctx context.Context, nodePub route.Vertex) (*models.Node,
 		error)
 
+	// HasV1Node determines if the graph has a vertex identified by
+	// the target node identity public key in the V1 graph. If the node
+	// exists in the database, a timestamp of when the data for the node
+	// was lasted updated is returned along with a true boolean. Otherwise,
+	// an empty time.Time is returned with a false boolean.
+	// This is specific to the V1 graph since only V1 node announcements
+	// use timestamps for their latest update timestamp.
+	HasV1Node(ctx context.Context, nodePub [33]byte) (time.Time, bool,
+		error)
+
 	// HasNode determines if the graph has a vertex identified by
-	// the target node identity public key. If the node exists in the
-	// database, a timestamp of when the data for the node was lasted
-	// updated is returned along with a true boolean. Otherwise, an empty
-	// time.Time is returned with a false boolean.
-	HasNode(ctx context.Context, nodePub [33]byte) (time.Time, bool, error)
+	// the target node identity public key.
+	HasNode(ctx context.Context, nodePub [33]byte) (bool, error)
 
 	// IsPublicNode is a helper method that determines whether the node with
 	// the given public key is seen as a public node in the graph from the

graph/db/kv_store.go

@@ -3431,12 +3431,12 @@ func (c *KVStore) fetchLightningNode(tx kvdb.RTx,
 	return node, nil
 }
 
-// HasLightningNode determines if the graph has a vertex identified by the
+// HasV1Node determines if the graph has a vertex identified by the
 // target node identity public key. If the node exists in the database, a
 // timestamp of when the data for the node was lasted updated is returned along
 // with a true boolean. Otherwise, an empty time.Time is returned with a false
 // boolean.
-func (c *KVStore) HasNode(_ context.Context,
+func (c *KVStore) HasV1Node(_ context.Context,
 	nodePub [33]byte) (time.Time, bool, error) {
 
 	var (
@@ -3484,6 +3484,39 @@ func (c *KVStore) HasNode(_ context.Context,
 	return updateTime, exists, nil
 }
 
+// HasNode determines if the graph has a vertex identified by the target node
+// identity public key.
+func (c *KVStore) HasNode(_ context.Context, nodePub [33]byte) (bool, error) {
+	var exists bool
+	err := kvdb.View(c.db, func(tx kvdb.RTx) error {
+		// First grab the nodes bucket which stores the mapping from
+		// pubKey to node information.
+		nodes := tx.ReadBucket(nodeBucket)
+		if nodes == nil {
+			return ErrGraphNotFound
+		}
+
+		// If a key for this serialized public key isn't found, we can
+		// exit early.
+		nodeBytes := nodes.Get(nodePub[:])
+		if nodeBytes == nil {
+			exists = false
+			return nil
+		}
+
+		exists = true
+
+		return nil
+	}, func() {
+		exists = false
+	})
+	if err != nil {
+		return exists, err
+	}
+
+	return exists, nil
+}
+
 // nodeTraversal is used to traverse all channels of a node given by its
 // public key and passes channel information into the specified callback.
 //

graph/db/sql_store.go

@@ -282,14 +282,14 @@ func (s *SQLStore) FetchNode(ctx context.Context,
 	return node, nil
 }
 
-// HasNode determines if the graph has a vertex identified by the
+// HasV1Node determines if the graph has a vertex identified by the
 // target node identity public key. If the node exists in the database, a
 // timestamp of when the data for the node was lasted updated is returned along
 // with a true boolean. Otherwise, an empty time.Time is returned with a false
 // boolean.
 //
 // NOTE: part of the Store interface.
-func (s *SQLStore) HasNode(ctx context.Context,
+func (s *SQLStore) HasV1Node(ctx context.Context,
 	pubKey [33]byte) (time.Time, bool, error) {
 
 	var (
@@ -325,6 +325,39 @@ func (s *SQLStore) HasNode(ctx context.Context,
 	return lastUpdate, exists, nil
 }
 
+// HasNode determines if the graph has a vertex identified by the
+// target node identity public key.
+//
+// NOTE: part of the Store interface.
+func (s *SQLStore) HasNode(ctx context.Context, pubKey [33]byte) (bool, error) {
+	var (
+		v      = lnwire.GossipVersion1
+		exists bool
+	)
+	err := s.db.ExecTx(ctx, sqldb.ReadTxOpt(), func(db SQLQueries) error {
+		_, err := db.GetNodeByPubKey(
+			ctx, sqlc.GetNodeByPubKeyParams{
+				Version: int16(v),
+				PubKey:  pubKey[:],
+			},
+		)
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil
+		} else if err != nil {
+			return fmt.Errorf("unable to fetch node: %w", err)
+		}
+
+		exists = true
+
+		return nil
+	}, sqldb.NoOpReset)
+	if err != nil {
+		return false, fmt.Errorf("unable to fetch node: %w", err)
+	}
+
+	return exists, nil
+}
+
 // AddrsForNode returns all known addresses for the target node public key
 // that the graph DB is aware of. The returned boolean indicates if the
 // given node is unknown to the graph DB or not.

routing/router_test.go

@@ -2717,11 +2717,11 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
 	copy(pub2[:], priv2.PubKey().SerializeCompressed())
 
 	// The two nodes we are about to add should not exist yet.
-	_, exists1, err := ctx.graph.HasNode(ctxb, pub1)
+	exists1, err := ctx.graph.HasNode(ctxb, pub1)
 	require.NoError(t, err, "unable to query graph")
 	require.False(t, exists1)
 
-	_, exists2, err := ctx.graph.HasNode(ctxb, pub2)
+	exists2, err := ctx.graph.HasNode(ctxb, pub2)
 	require.NoError(t, err, "unable to query graph")
 	require.False(t, exists2)
 
@@ -2778,11 +2778,11 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
 
 	// After adding the edge between the two previously unknown nodes, they
 	// should have been added to the graph.
-	_, exists1, err = ctx.graph.HasNode(ctxb, pub1)
+	exists1, err = ctx.graph.HasNode(ctxb, pub1)
 	require.NoError(t, err, "unable to query graph")
 	require.True(t, exists1)
 
-	_, exists2, err = ctx.graph.HasNode(ctxb, pub2)
+	exists2, err = ctx.graph.HasNode(ctxb, pub2)
 	require.NoError(t, err, "unable to query graph")
 	require.True(t, exists2)
 

rpcserver.go

@@ -1793,7 +1793,7 @@ func (r *rpcServer) VerifyMessage(ctx context.Context,
 	//
 	// TODO(phlip9): Require valid nodes to have capital in active channels.
 	graph := r.server.graphDB
-	_, active, err := graph.HasNode(ctx, pub)
+	active, err := graph.HasNode(ctx, pub)
 	if err != nil {
 		return nil, fmt.Errorf("failed to query graph: %w", err)
 	}