diff --git a/runtime/data_service.go b/runtime/data_service.go index 5848cbd..ac4b06d 100644 --- a/runtime/data_service.go +++ b/runtime/data_service.go @@ -718,19 +718,11 @@ func cloneSelectQuery(source *core.SelectQuery, entity string) *core.SelectQuery if source == nil { return core.NewSelectQuery(entity) } - clone := *source + // Each relation probe adds its own parent predicate. A shallow copy + // shares an existing AND expression and contaminates later parents. + clone := source.Clone() clone.Entity = entity - clone.Projection = append([]string(nil), source.Projection...) - clone.OrderBy = append([]*core.OrderBy(nil), source.OrderBy...) - clone.Relations = append([]*core.RelationLoad(nil), source.Relations...) - clone.RelationAggregates = append([]*core.RelationAggregate(nil), source.RelationAggregates...) - clone.Aggregates = append([]*core.Aggregate(nil), source.Aggregates...) - clone.GroupBy = append([]string(nil), source.GroupBy...) - if source.Slice != nil { - slice := *source.Slice - clone.Slice = &slice - } - return &clone + return clone } func (s *RuntimeDataService) enhanceRelationAggregates(context stdcontext.Context, parents []core.Record, query *core.SelectQuery, keys map[string][]core.Value, intent ...logprivacy.IntentSource) error { diff --git a/provider/sqlite/school_relation_probe_test.go b/provider/sqlite/school_relation_probe_test.go new file mode 100644 index 0000000..55daa0c --- /dev/null +++ b/provider/sqlite/school_relation_probe_test.go @@ -0,0 +1,111 @@ +package sqlite + +import ( + "database/sql" + "encoding/json" + "fmt" + "reflect" + "testing" + + "github.com/teaql/teaql-golang/core" + ds "github.com/teaql/teaql-golang/data_service" + "github.com/teaql/teaql-golang/runtime" + tsql "github.com/teaql/teaql-golang/sql" +) + +func TestSchoolFilteredRelationParentIsolation(t *testing.T) { + for _, wrapper := range []bool{false, true} { + for _, probes := range []bool{false, true} { + for _, active := range []bool{false, true} { + for _, descending := range []bool{false, true} { + t.Run(fmt.Sprintf("wrapper=%t/probes=%t/active=%t/descending=%t", wrapper, probes, active, descending), func(t *testing.T) { + db, err := sql.Open("sqlite3", ":memory:") + if err != nil { + t.Fatal(err) + } + defer db.Close() + db.SetMaxOpenConns(1) + // Provider-owned regression fixture; the generated School consumer + // independently creates its records through audited entity saves. + for _, statement := range []string{ + "CREATE TABLE school_type_data(id INTEGER PRIMARY KEY, version INTEGER, code TEXT)", + "CREATE TABLE school_data(id INTEGER PRIMARY KEY, version INTEGER, name TEXT, active INTEGER, capacity INTEGER, school_type INTEGER)", + "INSERT INTO school_type_data VALUES(1001,1,'PRIMARY'),(1002,1,'SECONDARY')", + "INSERT INTO school_data VALUES(1,1,'Riverside',1,800,1001),(2,1,'North',1,300,1001),(3,1,'West',1,500,1001),(4,1,'Lakeside',1,1200,1002),(5,1,'Hill',0,500,1002)", + } { + if _, err := db.Exec(statement); err != nil { + t.Fatal(err) + } + } + metadata := runtime.NewInMemoryMetadataStore() + metadata.Register(core.NewEntityDescriptor("SchoolType").TableName("school_type_data"). + Property(core.NewPropertyDescriptor("id", core.TypeU64).Id()). + Property(core.NewPropertyDescriptor("version", core.TypeI64).Version()). + Property(core.NewPropertyDescriptor("code", core.TypeText)). + Relation(core.NewRelationDescriptor("schools", "School").ForeignKey("school_type").Many())) + metadata.Register(core.NewEntityDescriptor("School").TableName("school_data"). + Property(core.NewPropertyDescriptor("id", core.TypeU64).Id()). + Property(core.NewPropertyDescriptor("version", core.TypeI64).Version()). + Property(core.NewPropertyDescriptor("name", core.TypeText)). + Property(core.NewPropertyDescriptor("active", core.TypeBool)). + Property(core.NewPropertyDescriptor("capacity", core.TypeI64)). + Property(core.NewPropertyDescriptor("school_type", core.TypeU64))) + transport := NewSqliteMutationExecutor(db) + var executor ds.DataServiceExecutor = tsql.NewSqlDataServiceExecutor(&SqliteDialect{}, transport, metadata) + if wrapper { + executor = runtime.NewSqlDataServiceExecutor(transport, &SqliteDialect{}, metadata) + } + service := runtime.NewRuntimeDataService(metadata, executor) + ctx := runtime.NewUserContext().WithDiagnosticSQLLogSink(nil) + child := core.NewSelectQuery("School").Project("id").Project("name"). + AndFilter(core.ExprGt("version", core.ValI64(0))).AndFilter(core.ExprEq("active", core.ValBool(active))). + OrderDesc("capacity").OrderAsc("id").Limit(2).TopNProbeParentThreshold(0) + if probes { + child.TopNProbeParentThreshold(32) + } + query := core.NewSelectQuery("SchoolType").Project("id").Project("code").Limit(10). + Comment("Load filtered School children").Purpose("Verify parent predicate isolation").RelationQuery("schools", child) + if descending { + query.OrderDesc("id") + } else { + query.OrderAsc("id") + } + before, err := json.Marshal(query) + if err != nil { + t.Fatal(err) + } + want := map[string][]string{"PRIMARY": {}, "SECONDARY": {"Hill"}} + if active { + want = map[string][]string{"PRIMARY": {"Riverside", "West"}, "SECONDARY": {"Lakeside"}} + } + for repeat := 0; repeat < 2; repeat++ { + rows, err := service.FetchAll(ctx, query) + if err != nil { + t.Fatal(err) + } + got := map[string][]string{} + for _, parent := range rows { + children, ok := parent["schools"].V.([]core.Record) + if !ok { + t.Fatalf("child list is not loaded: %#v", parent) + } + names := []string{} + for _, row := range children { + names = append(names, fmt.Sprint(row["name"].V)) + } + got[fmt.Sprint(parent["code"].V)] = names + } + if !reflect.DeepEqual(got, want) { + t.Fatalf("parent-specific results = %v, want %v", got, want) + } + after, err := json.Marshal(query) + if err != nil || string(after) != string(before) { + t.Fatalf("execution mutated the reusable query: %s -> %s (%v)", before, after, err) + } + } + }) + } + } + } + } +}