9367064922

Committed 04 Jun 2024 12:27PM UTC coverage: 89.43% (-0.02%) from 89.451%

Build # 9367064922

Build Type

push

gh-ci

Committed by

ostafen

Commit Message

Add support for JSON type

Signed-off-by: Stefano Scafiti <stefano.scafiti96@gmail.com>

Run Details

521 of 575 new or added lines in 14 files covered. (90.61%)

12 existing lines in 5 files now uncovered.

35172 of 39329 relevant lines covered (89.43%)

160547.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.22

/embedded/sql/proj_row_reader.go

/*
Copyright 2024 Codenotary Inc. All rights reserved.

SPDX-License-Identifier: BUSL-1.1
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://mariadb.com/bsl11/

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package sql

import (
        "context"
        "fmt"
)

type projectedRowReader struct {
        rowReader  RowReader
        tableAlias string

        selectors []Selector
}

func newProjectedRowReader(ctx context.Context, rowReader RowReader, tableAlias string, selectors []Selector) (*projectedRowReader, error) {
        // case: SELECT *
        if len(selectors) == 0 {
                cols, err := rowReader.Columns(ctx)
                if err != nil {
                        return nil, err
                }

                for _, col := range cols {
                        sel := &ColSelector{
                                table: col.Table,
                                col:   col.Column,
                        }
                        selectors = append(selectors, sel)
                }
        }

        return &projectedRowReader{
                rowReader:  rowReader,
                tableAlias: tableAlias,
                selectors:  selectors,
        }, nil
}

func (pr *projectedRowReader) onClose(callback func()) {
        pr.rowReader.onClose(callback)
}

func (pr *projectedRowReader) Tx() *SQLTx {
        return pr.rowReader.Tx()
}

func (pr *projectedRowReader) TableAlias() string {
        if pr.tableAlias == "" {
                return pr.rowReader.TableAlias()
        }

        return pr.tableAlias
}

func (pr *projectedRowReader) OrderBy() []ColDescriptor {
        return pr.rowReader.OrderBy()
}

func (pr *projectedRowReader) ScanSpecs() *ScanSpecs {
        return pr.rowReader.ScanSpecs()
}

func (pr *projectedRowReader) Columns(ctx context.Context) ([]ColDescriptor, error) {
        colsBySel, err := pr.colsBySelector(ctx)
        if err != nil {
                return nil, err
        }

        colsByPos := make([]ColDescriptor, len(pr.selectors))

        for i, sel := range pr.selectors {
                aggFn, table, col := sel.resolve(pr.rowReader.TableAlias())

                if pr.tableAlias != "" {
                        table = pr.tableAlias
                }

                if aggFn == "" && sel.alias() != "" {
                        col = sel.alias()
                }

                if aggFn != "" {
                        aggFn = ""
                        col = sel.alias()
                        if col == "" {
                                col = fmt.Sprintf("col%d", i)
                        }
                }

                colsByPos[i] = ColDescriptor{
                        AggFn:  aggFn,
                        Table:  table,
                        Column: col,
                }

                encSel := colsByPos[i].Selector()

                colsByPos[i].Type = colsBySel[encSel].Type
        }

        return colsByPos, nil
}

func (pr *projectedRowReader) colsBySelector(ctx context.Context) (map[string]ColDescriptor, error) {
        dsColDescriptors, err := pr.rowReader.colsBySelector(ctx)
        if err != nil {
                return nil, err
        }

        colDescriptors := make(map[string]ColDescriptor, len(pr.selectors))
        emptyParams := make(map[string]string)

        for i, sel := range pr.selectors {
                aggFn, table, col := sel.resolve(pr.rowReader.TableAlias())

                sqlType, err := sel.inferType(dsColDescriptors, emptyParams, pr.rowReader.TableAlias())
                if err != nil {
                        return nil, err
                }

                if pr.tableAlias != "" {
                        table = pr.tableAlias
                }

                if aggFn == "" && sel.alias() != "" {
                        col = sel.alias()
                }

                if aggFn != "" {
                        aggFn = ""
                        col = sel.alias()
                        if col == "" {
                                col = fmt.Sprintf("col%d", i)
                        }
                }

                des := ColDescriptor{
                        AggFn:  aggFn,
                        Table:  table,
                        Column: col,
                        Type:   sqlType,
                }

                colDescriptors[des.Selector()] = des
        }

        return colDescriptors, nil
}

func (pr *projectedRowReader) InferParameters(ctx context.Context, params map[string]SQLValueType) error {
        return pr.rowReader.InferParameters(ctx, params)
}

func (pr *projectedRowReader) Parameters() map[string]interface{} {
        return pr.rowReader.Parameters()
}

func (pr *projectedRowReader) Read(ctx context.Context) (*Row, error) {
        row, err := pr.rowReader.Read(ctx)
        if err != nil {
                return nil, err
        }

        prow := &Row{
                ValuesByPosition: make([]TypedValue, len(pr.selectors)),
                ValuesBySelector: make(map[string]TypedValue, len(pr.selectors)),
        }

        for i, sel := range pr.selectors {
                v, err := sel.reduce(pr.Tx(), row, pr.rowReader.TableAlias())
                if err != nil {
                        return nil, err
                }

                aggFn, table, col := sel.resolve(pr.rowReader.TableAlias())
                if pr.tableAlias != "" {
                        table = pr.tableAlias
                }

                if aggFn == "" && sel.alias() != "" {
                        col = sel.alias()
                }

                if aggFn != "" {
                        aggFn = ""
                        col = sel.alias()
                        if col == "" {
                                col = fmt.Sprintf("col%d", i)
                        }
                }

                prow.ValuesByPosition[i] = v
                prow.ValuesBySelector[EncodeSelector(aggFn, table, col)] = v
        }
        return prow, nil
}

func (pr *projectedRowReader) Close() error {
        return pr.rowReader.Close()
}

1	/*
2	Copyright 2024 Codenotary Inc. All rights reserved.
3
4	SPDX-License-Identifier: BUSL-1.1
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	https://mariadb.com/bsl11/
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	package sql
18
19	import (
20	"context"
21	"fmt"
22	)
23
24	type projectedRowReader struct {
25	rowReader RowReader
26	tableAlias string
27
28	selectors []Selector
29	}
30
31	func newProjectedRowReader(ctx context.Context, rowReader RowReader, tableAlias string, selectors []Selector) (*projectedRowReader, error) {	745✔
32	// case: SELECT *	745✔
33	if len(selectors) == 0 {	1,080✔
34	cols, err := rowReader.Columns(ctx)	335✔
35	if err != nil {	336✔
36	return nil, err	1✔
37	}	1✔
38
39	for _, col := range cols {	1,336✔
40	sel := &ColSelector{	1,002✔
41	table: col.Table,	1,002✔
42	col: col.Column,	1,002✔
43	}	1,002✔
44	selectors = append(selectors, sel)	1,002✔
45	}	1,002✔
46	}
47
48	return &projectedRowReader{	744✔
49	rowReader: rowReader,	744✔
50	tableAlias: tableAlias,	744✔
51	selectors: selectors,	744✔
52	}, nil	744✔
53	}
54
55	func (pr *projectedRowReader) onClose(callback func()) {	344✔
56	pr.rowReader.onClose(callback)	344✔
57	}	344✔
58
59	func (pr projectedRowReader) Tx() SQLTx {	77,011✔
60	return pr.rowReader.Tx()	77,011✔
61	}	77,011✔
62
63	func (pr *projectedRowReader) TableAlias() string {	14,608✔
64	if pr.tableAlias == "" {	29,145✔
65	return pr.rowReader.TableAlias()	14,537✔
66	}	14,537✔
67
68	return pr.tableAlias	71✔
69	}
70
71	func (pr *projectedRowReader) OrderBy() []ColDescriptor {	24✔
72	return pr.rowReader.OrderBy()	24✔
73	}	24✔
74
75	func (pr projectedRowReader) ScanSpecs() ScanSpecs {	91✔
76	return pr.rowReader.ScanSpecs()	91✔
77	}	91✔
78
79	func (pr *projectedRowReader) Columns(ctx context.Context) ([]ColDescriptor, error) {	124✔
80	colsBySel, err := pr.colsBySelector(ctx)	124✔
81	if err != nil {	125✔
82	return nil, err	1✔
83	}	1✔
84
85	colsByPos := make([]ColDescriptor, len(pr.selectors))	123✔
86		123✔
87	for i, sel := range pr.selectors {	418✔
88	aggFn, table, col := sel.resolve(pr.rowReader.TableAlias())	295✔
89		295✔
90	if pr.tableAlias != "" {	295✔
91	table = pr.tableAlias	×
92	}	×
93
94	if aggFn == "" && sel.alias() != "" {	566✔
95	col = sel.alias()	271✔
96	}	271✔
97
98	if aggFn != "" {	319✔
99	aggFn = ""	24✔
100	col = sel.alias()	24✔
101	if col == "" {	36✔
102	col = fmt.Sprintf("col%d", i)	12✔
103	}	12✔
104	}
105
106	colsByPos[i] = ColDescriptor{	295✔
107	AggFn: aggFn,	295✔
108	Table: table,	295✔
109	Column: col,	295✔
110	}	295✔
111		295✔
112	encSel := colsByPos[i].Selector()	295✔
113		295✔
114	colsByPos[i].Type = colsBySel[encSel].Type	295✔
115	}
116
117	return colsByPos, nil	123✔
118	}
119
120	func (pr *projectedRowReader) colsBySelector(ctx context.Context) (map[string]ColDescriptor, error) {	165✔
121	dsColDescriptors, err := pr.rowReader.colsBySelector(ctx)	165✔
122	if err != nil {	166✔
123	return nil, err	1✔
124	}	1✔
125
126	colDescriptors := make(map[string]ColDescriptor, len(pr.selectors))	164✔
127	emptyParams := make(map[string]string)	164✔
128		164✔
129	for i, sel := range pr.selectors {	550✔
130	aggFn, table, col := sel.resolve(pr.rowReader.TableAlias())	386✔
131		386✔
132	sqlType, err := sel.inferType(dsColDescriptors, emptyParams, pr.rowReader.TableAlias())	386✔
133	if err != nil {	386✔
NEW 134	return nil, err	×
UNCOV 135	}	×
136
137	if pr.tableAlias != "" {	391✔
138	table = pr.tableAlias	5✔
139	}	5✔
140
141	if aggFn == "" && sel.alias() != "" {	748✔
142	col = sel.alias()	362✔
143	}	362✔
144
145	if aggFn != "" {	410✔
146	aggFn = ""	24✔
147	col = sel.alias()	24✔
148	if col == "" {	36✔
149	col = fmt.Sprintf("col%d", i)	12✔
150	}	12✔
151	}
152
153	des := ColDescriptor{	386✔
154	AggFn: aggFn,	386✔
155	Table: table,	386✔
156	Column: col,	386✔
157	Type: sqlType,	386✔
158	}	386✔
159		386✔
160	colDescriptors[des.Selector()] = des	386✔
161	}
162
163	return colDescriptors, nil	164✔
164	}
165
166	func (pr *projectedRowReader) InferParameters(ctx context.Context, params map[string]SQLValueType) error {	52✔
167	return pr.rowReader.InferParameters(ctx, params)	52✔
168	}	52✔
169
170	func (pr *projectedRowReader) Parameters() map[string]interface{} {	27✔
171	return pr.rowReader.Parameters()	27✔
172	}	27✔
173
174	func (pr projectedRowReader) Read(ctx context.Context) (Row, error) {	15,268✔
175	row, err := pr.rowReader.Read(ctx)	15,268✔
176	if err != nil {	15,738✔
177	return nil, err	470✔
178	}	470✔
179
180	prow := &Row{	14,798✔
181	ValuesByPosition: make([]TypedValue, len(pr.selectors)),	14,798✔
182	ValuesBySelector: make(map[string]TypedValue, len(pr.selectors)),	14,798✔
183	}	14,798✔
184		14,798✔
185	for i, sel := range pr.selectors {	78,056✔
186	v, err := sel.reduce(pr.Tx(), row, pr.rowReader.TableAlias())	63,258✔
187	if err != nil {	63,262✔
188	return nil, err	4✔
189	}	4✔
190
191	aggFn, table, col := sel.resolve(pr.rowReader.TableAlias())	63,254✔
192	if pr.tableAlias != "" {	63,285✔
193	table = pr.tableAlias	31✔
194	}	31✔
195
196	if aggFn == "" && sel.alias() != "" {	126,121✔
197	col = sel.alias()	62,867✔
198	}	62,867✔
199
200	if aggFn != "" {	63,641✔
201	aggFn = ""	387✔
202	col = sel.alias()	387✔
203	if col == "" {	759✔
204	col = fmt.Sprintf("col%d", i)	372✔
205	}	372✔
206	}
207
208	prow.ValuesByPosition[i] = v	63,254✔
209	prow.ValuesBySelector[EncodeSelector(aggFn, table, col)] = v	63,254✔
210	}
211	return prow, nil	14,794✔
212	}
213
214	func (pr *projectedRowReader) Close() error {	738✔
215	return pr.rowReader.Close()	738✔
216	}	738✔

codenotary / immudb / 9367064922

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous