rraulinio commented on code in PR #1432:
URL: https://github.com/apache/iceberg-go/pull/1432#discussion_r3569404981


##########
catalog/rest/rest.go:
##########
@@ -2045,3 +2054,145 @@ func (r *Catalog) LoadView(ctx context.Context, 
identifier table.Identifier) (*v
 
        return view.New(identifier, metadata, rsp.MetadataLoc), nil
 }
+
+// Catalog implements the optional function (SQL UDF) read support defined
+// by the REST spec: list and load. The function endpoints are not part of
+// the spec's assumed default endpoint set, so they are only used when the
+// server advertises them.
+var _ catalog.FunctionCatalog = (*Catalog)(nil)
+
+// ListFunctions returns the function (SQL UDF) identifiers under a
+// namespace, with the returned identifiers containing the information
+// required to load the function via this catalog.
+func (r *Catalog) ListFunctions(ctx context.Context, namespace 
table.Identifier) iter.Seq2[table.Identifier, error] {
+       return func(yield func(table.Identifier, error) bool) {
+               pageSize := r.getPageSize(ctx)
+               var pageToken string
+
+               for {
+                       functions, nextPageToken, err := 
r.listFunctionsPage(ctx, namespace, pageToken, pageSize)
+                       if err != nil {
+                               yield(table.Identifier{}, err)
+
+                               return
+                       }
+                       for _, function := range functions {
+                               if !yield(function, nil) {
+                                       return
+                               }
+                       }
+                       if nextPageToken == "" {
+                               return
+                       }
+                       pageToken = nextPageToken
+               }
+       }
+}
+
+func (r *Catalog) listFunctionsPage(ctx context.Context, namespace 
table.Identifier, pageToken string, pageSize int) ([]table.Identifier, string, 
error) {
+       if err := checkValidNamespace(namespace); err != nil {
+               return nil, "", err
+       }
+       // Unsupported listing yields an empty result rather than an error.
+       if !r.endpoints.allowed(endpointListFunctions) {
+               return nil, "", nil
+       }
+       ns := r.encodeNamespace(namespace)
+       path, err := endpointListFunctions.reqPath(ns)
+       if err != nil {
+               return nil, "", err
+       }
+       uri := r.baseURI.JoinPath(path...)
+
+       v := url.Values{}
+       if pageSize > 0 {
+               v.Set("pageSize", strconv.Itoa(pageSize))
+       }
+       if pageToken != "" {
+               v.Set("pageToken", pageToken)
+       }
+
+       uri.RawQuery = v.Encode()
+       // Function identifiers are CatalogObjectIdentifier values: ordered
+       // hierarchy levels (the namespace levels followed by the function
+       // name), not the {namespace, name} object tables and views use.
+       type resp struct {
+               Identifiers   [][]string `json:"identifiers"`
+               NextPageToken string     `json:"next-page-token,omitempty"`
+       }
+
+       rsp, err := doGet[resp](ctx, uri, []string{}, r.cl, 
map[int]error{http.StatusNotFound: catalog.ErrNoSuchNamespace})
+       if err != nil {
+               return nil, "", err
+       }
+
+       out := make([]table.Identifier, len(rsp.Identifiers))
+       for i, levels := range rsp.Identifiers {
+               out[i] = table.Identifier(levels)
+       }
+
+       return out, rsp.NextPageToken, nil
+}
+
+// loadFunctionResponse contains the response from loading a function.
+type loadFunctionResponse struct {
+       MetadataLoc string          `json:"metadata-location"`
+       RawMetadata json.RawMessage `json:"metadata"`
+}
+
+// LoadFunction loads a function (SQL UDF) from the catalog. All overloaded
+// definitions are included in the single metadata response.
+func (r *Catalog) LoadFunction(ctx context.Context, identifier 
table.Identifier) (*udf.UDF, error) {
+       if err := r.endpoints.check(endpointLoadFunction); err != nil {
+               return nil, err
+       }
+
+       ns, fn, err := r.splitFunctionIdentForPath(identifier)
+       if err != nil {
+               return nil, err
+       }
+
+       path, err := endpointLoadFunction.reqPath(ns, fn)
+       if err != nil {
+               return nil, err
+       }
+
+       rsp, err := doGet[loadFunctionResponse](ctx, r.baseURI, path,
+               r.cl, map[int]error{
+                       http.StatusNotFound: catalog.ErrNoSuchFunction,

Review Comment:
   Fixed. `LoadFunction` now inspects the REST error type and maps 
`NoSuchNamespaceException` to `ErrNoSuchNamespace`, while 
`NoSuchFunctionException` remains `ErrNoSuchFunction`. Coverage was added for 
both `LoadFunction` and `CheckFunctionExists`.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to