Method Handler

runtime/ai/query_sql.go:54–117

(ctx context.Context, args *QuerySQLArgs)

}

func (t *QuerySQL) Handler(ctx context.Context, args *QuerySQLArgs) (*QuerySQLResult, error) {
	if args.SQL == "" {
		return nil, fmt.Errorf("sql query is required")
	}

	s := GetSession(ctx)

	// Apply timeout default
	timeoutSeconds := args.TimeoutSeconds
	if timeoutSeconds <= 0 {
		timeoutSeconds = 30
	}

	// Apply a hard limit to prevent large results that bloat the context
	instance, err := t.Runtime.Instance(ctx, s.InstanceID())
	if err != nil {
		return nil, fmt.Errorf("failed to get instance: %w", err)
	}
	cfg, err := instance.Config()
	if err != nil {
		return nil, fmt.Errorf("failed to get instance config: %w", err)
	}
	hardLimit := cfg.AIMaxQueryLimit

	// Apply timeout
	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
	defer cancel()

	// Build resolver properties with system limit
	props := map[string]any{
		"sql":   args.SQL,
		"limit": hardLimit,
	}
	if args.Connector != "" {
		props["connector"] = args.Connector
	}

	// Execute via the SQL resolver
	res, _, err := t.Runtime.Resolve(ctx, &runtime.ResolveOptions{
		InstanceID:         s.InstanceID(),
		Resolver:           "sql",
		ResolverProperties: props,
		Claims:             s.Claims(),
	})
	if err != nil {
		return nil, err
	}
	defer res.Close()

	// Collect results in tabular format
	schema, data, err := resolverResultToTabular(res)
	if err != nil {
		return nil, err
	}

	result := &QuerySQLResult{
		Schema: schema,
		Data:   data,