if false {
		sr.SkipEncrypted(true)
		return sr.DebugStream(os.Stdout)
	}
	extracted := false
	for {
		stream, err := sr.NextStream()
		if err != nil {
			if err == io.EOF {
				if extracted {
					return nil
				}
				return errors.New("no data found on stream")
			}
			if errors.Is(err, estream.ErrNoKey) {
				fmt.Println("Skipping", stream.Name, "no private key")
				if err := stream.Skip(); err != nil {

    @Mock
    SmbPipeHandleImpl handle;

    @Mock
    SmbTreeHandleImpl tree;

    @Mock
    SmbNamedPipe pipe;

    @Mock
    SmbFileHandleImpl fileHandle;

    private SmbPipeOutputStream newStream() throws CIFSException {
        // Arrange common constructor collaborators to avoid touching network/state
        when(handle.getPipe()).thenReturn(pipe);
        when(tree.isSMB2()).thenReturn(true);

```go
decoder := jstream.NewDecoder(f, 2).EmitKV() // enable KV streaming at a depth level of 2
```

```
jstream.KV{desc RGB}
jstream.KV{colors [red green blue]}
jstream.KV{desc CMYK}
jstream.KV{colors [cyan magenta yellow black]}
```

## Installing 

```bash
go get github.com/bcicen/jstream
```

## Commandline

    private ByteArrayOutputStream testOutput;
    private PrintStream testStream;
    private int originalLevel;

    @BeforeEach
    void setUp() throws Exception {
        // Save original state
        originalErr = System.err;
        originalLevel = LogStream.level;

        // Create test stream
        testOutput = new ByteArrayOutputStream();
        testStream = new PrintStream(testOutput);

	w.Flush()
	return w.Error()
}

// WriteJSON - encodes to JSON data.
func (r *Record) WriteJSON(writer io.Writer) error {
	var kvs jstream.KVS = make([]jstream.KV, 0, len(r.columnNames))
	for i, cn := range r.columnNames {
		if i < len(r.csvRecord) {
			kvs = append(kvs, jstream.KV{Key: cn, Value: r.csvRecord[i]})
		}
	}
	return json.NewEncoder(writer).Encode(kvs)
}

		return nil, io.EOF
	}

	var kvs jstream.KVS
	if v.ValueType == jstream.Object {
		// This is a JSON object type (that preserves key
		// order)
		kvs, _ = v.Value.(jstream.KVS)
	} else {
		// To be AWS S3 compatible Select for JSON needs to
		// output non-object JSON as single column value
		// i.e. a map with `_1` as key and value as the
		// non-object.
		kvs = jstream.KVS{jstream.KV{Key: "_1", Value: v.Value}}
	}

				}
				dst := r.kvDstPool.Get()
				if len(dst) < 1000 {
					dst = make([]jstream.KVS, 0, 1000)
				}

				d := jstream.NewDecoder(bytes.NewBuffer(in.input), 0).ObjectAsKVS().MaxDepth(100)
				stream := d.Stream()
				all := dst[:0]
				for mv := range stream {
					var kvs jstream.KVS
					if mv.ValueType == jstream.Object {
						// This is a JSON object type (that preserves key
						// order)

func (r *Record) Replace(k any) error {
	v, ok := k.(jstream.KVS)
	if !ok {
		return fmt.Errorf("cannot replace internal data in json record with type %T", k)
	}
	r.KVS = v
	return nil
}

// NewRecord - creates new empty JSON record.
func NewRecord(f sql.SelectObjectFormat) *Record {
	return &Record{
		KVS:          jstream.KVS{},
		SelectFormat: f,
	}
}

		return nil, errDataSource(errors.New("path not supported"))
	}
	switch rec := rawVal.(type) {
	case jstream.KVS:
		txedRec, _, err := jsonpathEval(e.selectAST.From.Table.PathExpr[1:], rec)
		if err != nil {
			return nil, err
		}

		var kvs jstream.KVS
		switch v := txedRec.(type) {
		case jstream.KVS:
			kvs = v

		case []any:
			recs := make([]*Record, len(v))
			for i, val := range v {

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package sql

import (
	"errors"

	"github.com/minio/minio/internal/s3select/jstream"
	"github.com/minio/simdjson-go"
)

var (
	errKeyLookup                  = errors.New("Cannot look up key in non-object value")
	errIndexLookup                = errors.New("Cannot look up array index in non-array value")