Method execute

core/gstate.go:658–912

(c context.Context, conn *sql.Conn)

}

func (s *gstate) execute(c context.Context, conn *sql.Conn) (err error) {

	if err = s.validateAndUpdateVars(c); err != nil {
		return
	}

	if s.cs.st.qc != nil {
		for i := range s.cs.st.qc.Selects {
			if msg := s.cs.st.qc.Selects[i].PartitionFilterRequired; msg != "" {
				return errors.New(msg)
			}
		}
	}

	var args args
	if args, err = s.argList(c); err != nil {
		return
	}

	cs := s.cs
	dbType := s.getTargetDBCtx().dbtype

	// Use Dialect to check for multi-statement scripts (e.g., SQLite)
	dialect := s.getTargetPsqlCompiler().GetDialect()
	parts := dialect.SplitQuery(cs.st.sql)

	if len(parts) > 1 {
		// Multi-statement script execution
		c1, span := s.gj.spanStart(c, "Execute Script")
		defer span.End()

		argIdx := 0
		for i, stmt := range parts {
			// Count parameters (?) in this statement to slice arguments
			nParams := strings.Count(stmt, "?")
			var stmtArgs []interface{}

			if nParams > 0 {
				if argIdx+nParams > len(args.values) {
					span.Error(fmt.Errorf("script: not enough arguments for statement %d", i))
					return fmt.Errorf("script: not enough arguments")
				}
				stmtArgs = args.values[argIdx : argIdx+nParams]
				argIdx += nParams
			}

			stmt, stmtArgs, err = prepareQueryArgsForDB(s.getTargetDBCtx().dbtype, stmt, stmtArgs)
			if err != nil {
				span.Error(err)
				return err
			}

			upperStmt := strings.ToUpper(strings.TrimSpace(stmt))

			isReturning := strings.Contains(upperStmt, "RETURNING")
			isSelect := (strings.HasPrefix(upperStmt, "SELECT") && !strings.Contains(upperStmt, " INTO ")) || strings.HasPrefix(upperStmt, "WITH")

			// Check for @gj_ids hint