Method RecordQuery

core/record_query.go:26–165

RecordQuery returns a new Record select query from a collection model, id or name. In case a collection id or name is provided and that collection doesn't actually exists, the generated query will be created with a cancelled context and will fail once an executor (Row(), One(), All(), etc.) is call

(collectionModelOrIdentifier any)

// actually exists, the generated query will be created with a cancelled context
// and will fail once an executor (Row(), One(), All(), etc.) is called.
func (app *BaseApp) RecordQuery(collectionModelOrIdentifier any) *dbx.SelectQuery {
	var tableName string

	collection, collectionErr := getCollectionByModelOrIdentifier(app, collectionModelOrIdentifier)
	if collection != nil {
		tableName = collection.Name
	}
	if tableName == "" {
		// update with some fake table name for easier debugging
		tableName = "@@__invalidCollectionModelOrIdentifier"
	}

	query := app.ConcurrentDB().Select(app.ConcurrentDB().QuoteSimpleColumnName(tableName) + ".*").From(tableName)

	// in case of an error attach a new context and cancel it immediately with the error
	if collectionErr != nil {
		ctx, cancelFunc := context.WithCancelCause(context.Background())
		query.WithContext(ctx)
		cancelFunc(collectionErr)
	}

	return query.WithBuildHook(func(q *dbx.Query) {
		q.WithExecHook(execLockRetry(app.config.QueryTimeout, defaultMaxLockRetries)).
			WithOneHook(func(q *dbx.Query, a any, op func(b any) error) error {
				if a == nil {
					return op(a)
				}

				switch v := a.(type) {
				case *Record:
					record, err := resolveRecordOneHook(collection, op)
					if err != nil {
						return err
					}

					*v = *record

					return nil
				case RecordProxy:
					record, err := resolveRecordOneHook(collection, op)
					if err != nil {
						return err
					}

					v.SetProxyRecord(record)
					return nil
				default:
					return op(a)
				}
			}).
			WithAllHook(func(q *dbx.Query, sliceA any, op func(sliceB any) error) error {
				if sliceA == nil {
					return op(sliceA)
				}

				switch v := sliceA.(type) {
				case *[]*Record:
					records, err := resolveRecordAllHook(collection, op)