graph/db+sqldb: remove LEFT JOIN for fetching node addresses

In this commit, we remove the LEFT JOIN query that was used for fetching
a nodes addresses. The reason it was used before was to ensure that we'd
get an empty address list if the node did exist but had no addresses.
This was for the purposes of the `AddrsForNode` method since it needs to
return false/true to indicate if the given node exists.

graph/db/sql_store.go

@@ -73,7 +73,7 @@ type SQLQueries interface {
 	DeleteExtraNodeType(ctx context.Context, arg sqlc.DeleteExtraNodeTypeParams) error
 
 	InsertNodeAddress(ctx context.Context, arg sqlc.InsertNodeAddressParams) error
-	GetNodeAddressesByPubKey(ctx context.Context, arg sqlc.GetNodeAddressesByPubKeyParams) ([]sqlc.GetNodeAddressesByPubKeyRow, error)
+	GetNodeAddresses(ctx context.Context, nodeID int64) ([]sqlc.GetNodeAddressesRow, error)
 	DeleteNodeAddresses(ctx context.Context, nodeID int64) error
 
 	InsertNodeFeature(ctx context.Context, arg sqlc.InsertNodeFeatureParams) error
@@ -321,10 +321,21 @@ func (s *SQLStore) AddrsForNode(ctx context.Context,
 		known     bool
 	)
 	err := s.db.ExecTx(ctx, sqldb.ReadTxOpt(), func(db SQLQueries) error {
-		var err error
+		// First, check if the node exists and get its DB ID if it
-		known, addresses, err = getNodeAddresses(
+		// does.
-			ctx, db, nodePub.SerializeCompressed(),
+		dbID, err := db.GetNodeIDByPubKey(
+			ctx, sqlc.GetNodeIDByPubKeyParams{
+				Version: int16(ProtocolV1),
+				PubKey:  nodePub.SerializeCompressed(),
+			},
 		)
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil
+		}
+
+		known = true
+
+		addresses, err = getNodeAddresses(ctx, db, dbID)
 		if err != nil {
 			return fmt.Errorf("unable to fetch node addresses: %w",
 				err)
@@ -3381,7 +3392,7 @@ func buildNode(ctx context.Context, db SQLQueries, dbNode *sqlc.GraphNode) (
 	}
 
 	// Fetch the node's addresses.
-	_, node.Addresses, err = getNodeAddresses(ctx, db, pub[:])
+	node.Addresses, err = getNodeAddresses(ctx, db, dbNode.ID)
 	if err != nil {
 		return nil, fmt.Errorf("unable to fetch node(%d) "+
 			"addresses: %w", dbNode.ID, err)
@@ -3685,42 +3696,26 @@ func upsertNodeAddresses(ctx context.Context, db SQLQueries, nodeID int64,
 	return nil
 }
 
-// getNodeAddresses fetches the addresses for a node with the given public key.
+// getNodeAddresses fetches the addresses for a node with the given DB ID.
-func getNodeAddresses(ctx context.Context, db SQLQueries, nodePub []byte) (bool,
+func getNodeAddresses(ctx context.Context, db SQLQueries, id int64) ([]net.Addr,
-	[]net.Addr, error) {
+	error) {
 
-	// GetNodeAddressesByPubKey ensures that the addresses for a given type
+	// GetNodeAddresses ensures that the addresses for a given type are
-	// are returned in the same order as they were inserted.
+	// returned in the same order as they were inserted.
-	rows, err := db.GetNodeAddressesByPubKey(
+	rows, err := db.GetNodeAddresses(ctx, id)
-		ctx, sqlc.GetNodeAddressesByPubKeyParams{
-			Version: int16(ProtocolV1),
-			PubKey:  nodePub,
-		},
-	)
 	if err != nil {
-		return false, nil, err
+		return nil, err
-	}
-
-	// GetNodeAddressesByPubKey uses a left join so there should always be
-	// at least one row returned if the node exists even if it has no
-	// addresses.
-	if len(rows) == 0 {
-		return false, nil, nil
 	}
 
 	addresses := make([]net.Addr, 0, len(rows))
-	for _, addr := range rows {
+	for _, row := range rows {
-		if !(addr.Type.Valid && addr.Address.Valid) {
+		address := row.Address
-			continue
-		}
 
-		address := addr.Address.String
+		switch dbAddressType(row.Type) {
-
-		switch dbAddressType(addr.Type.Int16) {
 		case addressTypeIPv4:
 			tcp, err := net.ResolveTCPAddr("tcp4", address)
 			if err != nil {
-				return false, nil, nil
+				return nil, err
 			}
 			tcp.IP = tcp.IP.To4()
 
@@ -3729,21 +3724,20 @@ func getNodeAddresses(ctx context.Context, db SQLQueries, nodePub []byte) (bool,
 		case addressTypeIPv6:
 			tcp, err := net.ResolveTCPAddr("tcp6", address)
 			if err != nil {
-				return false, nil, nil
+				return nil, err
 			}
 			addresses = append(addresses, tcp)
 
 		case addressTypeTorV3, addressTypeTorV2:
 			service, portStr, err := net.SplitHostPort(address)
 			if err != nil {
-				return false, nil, fmt.Errorf("unable to "+
+				return nil, fmt.Errorf("unable to "+
-					"split tor v3 address: %v",
+					"split tor v3 address: %v", address)
-					addr.Address)
 			}
 
 			port, err := strconv.Atoi(portStr)
 			if err != nil {
-				return false, nil, err
+				return nil, err
 			}
 
 			addresses = append(addresses, &tor.OnionAddr{
@@ -3754,8 +3748,8 @@ func getNodeAddresses(ctx context.Context, db SQLQueries, nodePub []byte) (bool,
 		case addressTypeOpaque:
 			opaque, err := hex.DecodeString(address)
 			if err != nil {
-				return false, nil, fmt.Errorf("unable to "+
+				return nil, fmt.Errorf("unable to "+
-					"decode opaque address: %v", addr)
+					"decode opaque address: %v", address)
 			}
 
 			addresses = append(addresses, &lnwire.OpaqueAddrs{
@@ -3763,8 +3757,8 @@ func getNodeAddresses(ctx context.Context, db SQLQueries, nodePub []byte) (bool,
 			})
 
 		default:
-			return false, nil, fmt.Errorf("unknown address "+
+			return nil, fmt.Errorf("unknown address type: %v",
-				"type: %v", addr.Type)
+				row.Type)
 		}
 	}
 
@@ -3774,7 +3768,7 @@ func getNodeAddresses(ctx context.Context, db SQLQueries, nodePub []byte) (bool,
 		addresses = nil
 	}
 
-	return true, addresses, nil
+	return addresses, nil
 }
 
 // upsertNodeExtraSignedFields updates the node's extra signed fields in the

sqldb/sqlc/graph.sql.go

@@ -1438,33 +1438,27 @@ func (q *Queries) GetExtraNodeTypes(ctx context.Context, nodeID int64) ([]GraphN
 	return items, nil
 }
 
-const getNodeAddressesByPubKey = `-- name: GetNodeAddressesByPubKey :many
+const getNodeAddresses = `-- name: GetNodeAddresses :many
-SELECT a.type, a.address
+SELECT type, address
-FROM graph_nodes n
+FROM graph_node_addresses
-LEFT JOIN graph_node_addresses a ON a.node_id = n.id
+WHERE node_id = $1
-WHERE n.pub_key = $1 AND n.version = $2
+ORDER BY type ASC, position ASC
-ORDER BY a.type ASC, a.position ASC
 `
 
-type GetNodeAddressesByPubKeyParams struct {
+type GetNodeAddressesRow struct {
-	PubKey  []byte
+	Type    int16
-	Version int16
+	Address string
 }
 
-type GetNodeAddressesByPubKeyRow struct {
+func (q *Queries) GetNodeAddresses(ctx context.Context, nodeID int64) ([]GetNodeAddressesRow, error) {
-	Type    sql.NullInt16
+	rows, err := q.db.QueryContext(ctx, getNodeAddresses, nodeID)
-	Address sql.NullString
-}
-
-func (q *Queries) GetNodeAddressesByPubKey(ctx context.Context, arg GetNodeAddressesByPubKeyParams) ([]GetNodeAddressesByPubKeyRow, error) {
-	rows, err := q.db.QueryContext(ctx, getNodeAddressesByPubKey, arg.PubKey, arg.Version)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetNodeAddressesByPubKeyRow
+	var items []GetNodeAddressesRow
 	for rows.Next() {
-		var i GetNodeAddressesByPubKeyRow
+		var i GetNodeAddressesRow
 		if err := rows.Scan(&i.Type, &i.Address); err != nil {
 			return nil, err
 		}

sqldb/sqlc/querier.go

@@ -59,7 +59,7 @@ type Querier interface {
 	GetInvoiceHTLCs(ctx context.Context, invoiceID int64) ([]InvoiceHtlc, error)
 	GetKVInvoicePaymentHashByAddIndex(ctx context.Context, addIndex int64) ([]byte, error)
 	GetMigration(ctx context.Context, version int32) (time.Time, error)
-	GetNodeAddressesByPubKey(ctx context.Context, arg GetNodeAddressesByPubKeyParams) ([]GetNodeAddressesByPubKeyRow, error)
+	GetNodeAddresses(ctx context.Context, nodeID int64) ([]GetNodeAddressesRow, error)
 	GetNodeByPubKey(ctx context.Context, arg GetNodeByPubKeyParams) (GraphNode, error)
 	GetNodeFeatures(ctx context.Context, nodeID int64) ([]GraphNodeFeature, error)
 	GetNodeFeaturesByPubKey(ctx context.Context, arg GetNodeFeaturesByPubKeyParams) ([]int32, error)

sqldb/sqlc/queries/graph.sql

@@ -134,12 +134,11 @@ INSERT INTO graph_node_addresses (
     $1, $2, $3, $4
  );
 
--- name: GetNodeAddressesByPubKey :many
+-- name: GetNodeAddresses :many
-SELECT a.type, a.address
+SELECT type, address
-FROM graph_nodes n
+FROM graph_node_addresses
-LEFT JOIN graph_node_addresses a ON a.node_id = n.id
+WHERE node_id = $1
-WHERE n.pub_key = $1 AND n.version = $2
+ORDER BY type ASC, position ASC;
-ORDER BY a.type ASC, a.position ASC;
 
 -- name: GetNodesByLastUpdateRange :many
 SELECT *