12312320175

Committed 13 Dec 2024 08:39AM UTC coverage: 89.246% (-0.01%) from 89.257%

Build # 12312320175

Build Type

push

gh-ci

Committed by

ostafen

Commit Message

Implement constant selection queries

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

Run Details

110 of 111 new or added lines in 2 files covered. (99.1%)

12 existing lines in 4 files now uncovered.

37635 of 42170 relevant lines covered (89.25%)

151276.06 hits per line

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

91.19

/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

        targets []TargetEntry
}

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

                if len(cols) == 0 {
                        return nil, fmt.Errorf("SELECT * with no tables specified is not valid")
                }

                for _, col := range cols {
                        targets = append(targets, TargetEntry{
                                Exp: &ColSelector{
                                        table: col.Table,
                                        col:   col.Column,
                                },
                        })
                }
        }

        return &projectedRowReader{
                rowReader:  rowReader,
                tableAlias: tableAlias,
                targets:    targets,
        }, 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.targets))

        for i, t := range pr.targets {
                var aggFn, table, col string = "", pr.rowReader.TableAlias(), ""
                if s, ok := t.Exp.(Selector); ok {
                        aggFn, table, col = s.resolve(pr.rowReader.TableAlias())
                }

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

                if t.As != "" {
                        col = t.As
                } else if aggFn != "" || col == "" {
                        col = fmt.Sprintf("col%d", i)
                }
                aggFn = ""

                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.targets))
        emptyParams := make(map[string]string)

        for i, t := range pr.targets {
                var aggFn, table, col string = "", pr.rowReader.TableAlias(), ""
                if s, ok := t.Exp.(Selector); ok {
                        aggFn, table, col = s.resolve(pr.rowReader.TableAlias())
                }

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

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

                if t.As != "" {
                        col = t.As
                } else if aggFn != "" || col == "" {
                        col = fmt.Sprintf("col%d", i)
                }
                aggFn = ""

                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 {
        if err := pr.rowReader.InferParameters(ctx, params); err != nil {
                return err
        }

        cols, err := pr.rowReader.colsBySelector(ctx)
        if err != nil {
                return err
        }

        for _, ex := range pr.targets {
                _, err = ex.Exp.inferType(cols, params, pr.TableAlias())
                if err != nil {
                        return err
                }
        }
        return nil
}

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.targets)),
                ValuesBySelector: make(map[string]TypedValue, len(pr.targets)),
        }

        for i, t := range pr.targets {
                e, err := t.Exp.substitute(pr.Parameters())
                if err != nil {
                        return nil, fmt.Errorf("%w: when evaluating WHERE clause", err)
                }

                v, err := e.reduce(pr.Tx(), row, pr.rowReader.TableAlias())
                if err != nil {
                        return nil, err
                }

                var aggFn, table, col string = "", pr.rowReader.TableAlias(), ""
                if s, ok := t.Exp.(Selector); ok {
                        aggFn, table, col = s.resolve(pr.rowReader.TableAlias())
                }

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

                if t.As != "" {
                        col = t.As
                } else if aggFn != "" || col == "" {
                        col = fmt.Sprintf("col%d", i)
                }

                prow.ValuesByPosition[i] = v
                prow.ValuesBySelector[EncodeSelector("", 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	targets []TargetEntry
29	}
30
31	func newProjectedRowReader(ctx context.Context, rowReader RowReader, tableAlias string, targets []TargetEntry) (*projectedRowReader, error) {	930✔
32	// case: SELECT *	930✔
33	if len(targets) == 0 {	1,407✔
34	cols, err := rowReader.Columns(ctx)	477✔
35	if err != nil {	478✔
36	return nil, err	1✔
37	}	1✔
38
39	if len(cols) == 0 {	478✔
40	return nil, fmt.Errorf("SELECT * with no tables specified is not valid")	2✔
41	}	2✔
42
43	for _, col := range cols {	2,183✔
44	targets = append(targets, TargetEntry{	1,709✔
45	Exp: &ColSelector{	1,709✔
46	table: col.Table,	1,709✔
47	col: col.Column,	1,709✔
48	},	1,709✔
49	})	1,709✔
50	}	1,709✔
51	}
52
53	return &projectedRowReader{	927✔
54	rowReader: rowReader,	927✔
55	tableAlias: tableAlias,	927✔
56	targets: targets,	927✔
57	}, nil	927✔
58	}
59
60	func (pr *projectedRowReader) onClose(callback func()) {	409✔
61	pr.rowReader.onClose(callback)	409✔
62	}	409✔
63
64	func (pr projectedRowReader) Tx() SQLTx {	164,058✔
65	return pr.rowReader.Tx()	164,058✔
66	}	164,058✔
67
68	func (pr *projectedRowReader) TableAlias() string {	16,065✔
69	if pr.tableAlias == "" {	32,030✔
70	return pr.rowReader.TableAlias()	15,965✔
71	}	15,965✔
72
73	return pr.tableAlias	100✔
74	}
75
76	func (pr *projectedRowReader) OrderBy() []ColDescriptor {	24✔
77	return pr.rowReader.OrderBy()	24✔
78	}	24✔
79
80	func (pr projectedRowReader) ScanSpecs() ScanSpecs {	101✔
81	return pr.rowReader.ScanSpecs()	101✔
82	}	101✔
83
84	func (pr *projectedRowReader) Columns(ctx context.Context) ([]ColDescriptor, error) {	125✔
85	colsBySel, err := pr.colsBySelector(ctx)	125✔
86	if err != nil {	125✔
UNCOV 87	return nil, err	×
UNCOV 88	}	×
89
90	colsByPos := make([]ColDescriptor, len(pr.targets))	125✔
91		125✔
92	for i, t := range pr.targets {	426✔
93	var aggFn, table, col string = "", pr.rowReader.TableAlias(), ""	301✔
94	if s, ok := t.Exp.(Selector); ok {	599✔
95	aggFn, table, col = s.resolve(pr.rowReader.TableAlias())	298✔
96	}	298✔
97
98	if pr.tableAlias != "" {	301✔
99	table = pr.tableAlias	×
100	}	×
101
102	if t.As != "" {	318✔
103	col = t.As	17✔
104	} else if aggFn != "" \|\| col == "" {	316✔
105	col = fmt.Sprintf("col%d", i)	15✔
106	}	15✔
107	aggFn = ""	301✔
108		301✔
109	colsByPos[i] = ColDescriptor{	301✔
110	AggFn: aggFn,	301✔
111	Table: table,	301✔
112	Column: col,	301✔
113	}	301✔
114	encSel := colsByPos[i].Selector()	301✔
115	colsByPos[i].Type = colsBySel[encSel].Type	301✔
116	}
117	return colsByPos, nil	125✔
118	}
119
120	func (pr *projectedRowReader) colsBySelector(ctx context.Context) (map[string]ColDescriptor, error) {	170✔
121	dsColDescriptors, err := pr.rowReader.colsBySelector(ctx)	170✔
122	if err != nil {	170✔
UNCOV 123	return nil, err	×
UNCOV 124	}	×
125
126	colDescriptors := make(map[string]ColDescriptor, len(pr.targets))	170✔
127	emptyParams := make(map[string]string)	170✔
128		170✔
129	for i, t := range pr.targets {	586✔
130	var aggFn, table, col string = "", pr.rowReader.TableAlias(), ""	416✔
131	if s, ok := t.Exp.(Selector); ok {	829✔
132	aggFn, table, col = s.resolve(pr.rowReader.TableAlias())	413✔
133	}	413✔
134
135	sqlType, err := t.Exp.inferType(dsColDescriptors, emptyParams, pr.rowReader.TableAlias())	416✔
136	if err != nil {	416✔
137	return nil, err	×
138	}	×
139
140	if pr.tableAlias != "" {	421✔
141	table = pr.tableAlias	5✔
142	}	5✔
143
144	if t.As != "" {	434✔
145	col = t.As	18✔
146	} else if aggFn != "" \|\| col == "" {	431✔
147	col = fmt.Sprintf("col%d", i)	15✔
148	}	15✔
149	aggFn = ""	416✔
150		416✔
151	des := ColDescriptor{	416✔
152	AggFn: aggFn,	416✔
153	Table: table,	416✔
154	Column: col,	416✔
155	Type: sqlType,	416✔
156	}	416✔
157	colDescriptors[des.Selector()] = des	416✔
158	}
159	return colDescriptors, nil	170✔
160	}
161
162	func (pr *projectedRowReader) InferParameters(ctx context.Context, params map[string]SQLValueType) error {	52✔
163	if err := pr.rowReader.InferParameters(ctx, params); err != nil {	61✔
164	return err	9✔
165	}	9✔
166
167	cols, err := pr.rowReader.colsBySelector(ctx)	43✔
168	if err != nil {	43✔
169	return err	×
170	}	×
171
172	for _, ex := range pr.targets {	172✔
173	_, err = ex.Exp.inferType(cols, params, pr.TableAlias())	129✔
174	if err != nil {	129✔
175	return err	×
176	}	×
177	}
178	return nil	43✔
179	}
180
181	func (pr *projectedRowReader) Parameters() map[string]interface{} {	150,610✔
182	return pr.rowReader.Parameters()	150,610✔
183	}	150,610✔
184
185	func (pr projectedRowReader) Read(ctx context.Context) (Row, error) {	28,213✔
186	row, err := pr.rowReader.Read(ctx)	28,213✔
187	if err != nil {	28,849✔
188	return nil, err	636✔
189	}	636✔
190
191	prow := &Row{	27,577✔
192	ValuesByPosition: make([]TypedValue, len(pr.targets)),	27,577✔
193	ValuesBySelector: make(map[string]TypedValue, len(pr.targets)),	27,577✔
194	}	27,577✔
195		27,577✔
196	for i, t := range pr.targets {	177,363✔
197	e, err := t.Exp.substitute(pr.Parameters())	149,786✔
198	if err != nil {	149,786✔
199	return nil, fmt.Errorf("%w: when evaluating WHERE clause", err)	×
200	}	×
201
202	v, err := e.reduce(pr.Tx(), row, pr.rowReader.TableAlias())	149,786✔
203	if err != nil {	149,806✔
204	return nil, err	20✔
205	}	20✔
206
207	var aggFn, table, col string = "", pr.rowReader.TableAlias(), ""	149,766✔
208	if s, ok := t.Exp.(Selector); ok {	298,776✔
209	aggFn, table, col = s.resolve(pr.rowReader.TableAlias())	149,010✔
210	}	149,010✔
211
212	if pr.tableAlias != "" {	149,797✔
213	table = pr.tableAlias	31✔
214	}	31✔
215
216	if t.As != "" {	150,321✔
217	col = t.As	555✔
218	} else if aggFn != "" \|\| col == "" {	150,689✔
219	col = fmt.Sprintf("col%d", i)	923✔
220	}	923✔
221
222	prow.ValuesByPosition[i] = v	149,766✔
223	prow.ValuesBySelector[EncodeSelector("", table, col)] = v	149,766✔
224	}
225	return prow, nil	27,557✔
226	}
227
228	func (pr *projectedRowReader) Close() error {	938✔
229	return pr.rowReader.Close()	938✔
230	}	938✔

codenotary / immudb / 12312320175

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