func (stmt *cypherStmt) Exec(args []driver.Value) (driver.Result, error) {
	if stmt.c.transaction != nil {
		err := stmt.c.transaction.query(stmt.query, args)
		// TODO add counts and error support
		return driver.RowsAffected(0), err
	}
	rows, err := stmt.Query(args)
	if rows != nil {
		defer rows.Close()
	}
	// TODO add counts and error support
	return driver.RowsAffected(0), err
}

func (c *conn) exec(stmt parser.Statement, args []driver.Value) (driver.Result, error) {
	rows, err := c.query(stmt, args)
	if err != nil {
		return nil, err
	}
	return driver.RowsAffected(len(rows.rows)), nil
}

func (s *fakeStmt) execInsert(args []driver.Value) (driver.Result, error) {
	db := s.c.db
	if len(args) != s.placeholders {
		panic("error in pkg db; should only get here if size is correct")
	}
	db.mu.Lock()
	t, ok := db.table(s.table)
	db.mu.Unlock()
	if !ok {
		return nil, fmt.Errorf("fakedb: table %q doesn't exist", s.table)
	}

	t.mu.Lock()
	defer t.mu.Unlock()

	cols := make([]interface{}, len(t.colname))
	argPos := 0
	for n, colname := range s.colName {
		colidx := t.columnIndex(colname)
		if colidx == -1 {
			return nil, fmt.Errorf("fakedb: column %q doesn't exist or dropped since prepared statement was created", colname)
		}
		var val interface{}
		if strvalue, ok := s.colValue[n].(string); ok && strvalue == "?" {
			val = args[argPos]
			argPos++
		} else {
			val = s.colValue[n]
		}
		cols[colidx] = val
	}

	t.rows = append(t.rows, &row{cols: cols})
	return driver.RowsAffected(1), nil
}

func (c *conn) Exec(stmt string, args []driver.Value) (driver.Result, error) {
	rows, err := c.Query(stmt, args)
	if err != nil {
		return nil, err
	}
	return driver.RowsAffected(len(rows.rows)), nil
}

func (cn *Conn) Exec(query string, args []interface{}) (driver.Result, error) {
	if len(args) == 0 {
		err := cn.p.SimpleQuery(query)
		if err != nil {
			return nil, err
		}

		var serr error
		for {
			m, err := cn.p.Next()
			if err != nil {
				return nil, err
			}

			switch m.Type {
			case 'E':
				serr = m.Err
			case 'Z':
				return driver.RowsAffected(0), serr
			}
		}
	} else {
		stmt, err := cn.Prepare(query)
		if err != nil {
			return nil, err
		}

		return stmt.Exec(args)
	}

	panic("not reached")
}

// Exec inserts values into the COPY stream. The insert is asynchronous
// and Exec can return errors from previous Exec calls to the same
// COPY stmt.
//
// You need to call Exec(nil) to sync the COPY stream and to get any
// errors from pending data, since Stmt.Close() doesn't return errors
// to the user.
func (ci *copyin) Exec(v []driver.Value) (r driver.Result, err error) {
	defer errRecover(&err)

	if ci.closed {
		return nil, errCopyInClosed
	}

	if ci.isErrorSet() {
		return nil, ci.err
	}

	if len(v) == 0 {
		err = ci.Close()
		ci.closed = true
		return nil, err
	}

	numValues := len(v)
	for i, value := range v {
		ci.buffer = appendEncodedText(&ci.cn.parameterStatus, ci.buffer, value)
		if i < numValues-1 {
			ci.buffer = append(ci.buffer, '\t')
		}
	}

	ci.buffer = append(ci.buffer, '\n')

	if len(ci.buffer) > ciBufferFlushSize {
		ci.flush(ci.buffer)
		// reset buffer, keep bytes for message identifier and length
		ci.buffer = ci.buffer[:5]
	}

	return driver.RowsAffected(0), nil
}

func (c *sqlConn) Exec(query string, args []driver.Value) (driver.Result, error) {
	n, err := c.conn.Execute(query, paramsFromValues(nil, args)...)
	if err != nil {
		return nil, err
	}

	return driver.RowsAffected(n), nil
}

func (c *conn) Exec(stmt string, args []driver.Value) (driver.Result, error) {
	result, err := c.internalQuery(stmt, args)
	if err != nil {
		return nil, err
	}
	switch t := result.GetUnion().(type) {
	case nil:
		return nil, nil
	case *Response_Result_DDL_:
		return driver.ResultNoRows, nil
	case *Response_Result_RowsAffected:
		return driver.RowsAffected(int(t.RowsAffected)), nil
	case *Response_Result_Rows_:
		return driver.RowsAffected(len(t.Rows.Rows)), nil
	default:
		return nil, util.Errorf("unexpected result %s of type %T", t, t)
	}
}

func (s *stmt) Exec(args []driver.Value) (driver.Result, error) {
	if err := s.st.Execute(args); err != nil {
		return nil, err
	}

	rowsAffected, err := s.st.RowsAffected()
	r := driver.RowsAffected(rowsAffected)
	return r, err
}

func (c *Conn) Exec(query string, argsV []driver.Value) (driver.Result, error) {
	if !c.conn.IsAlive() {
		return nil, driver.ErrBadConn
	}

	args := valueToInterface(argsV)
	commandTag, err := c.conn.Exec(query, args...)
	return driver.RowsAffected(commandTag.RowsAffected()), err
}

// parseComplete parses the "command tag" from a CommandComplete message, and
// returns the number of rows affected (if applicable) and a string
// identifying only the command that was executed, e.g. "ALTER TABLE".  If the
// command tag could not be parsed, parseComplete panics.
func (cn *conn) parseComplete(commandTag string) (driver.Result, string) {
	commandsWithAffectedRows := []string{
		"SELECT ",
		// INSERT is handled below
		"UPDATE ",
		"DELETE ",
		"FETCH ",
		"MOVE ",
		"COPY ",
	}

	var affectedRows *string
	for _, tag := range commandsWithAffectedRows {
		if strings.HasPrefix(commandTag, tag) {
			t := commandTag[len(tag):]
			affectedRows = &t
			commandTag = tag[:len(tag)-1]
			break
		}
	}
	// INSERT also includes the oid of the inserted row in its command tag.
	// Oids in user tables are deprecated, and the oid is only returned when
	// exactly one row is inserted, so it's unlikely to be of value to any
	// real-world application and we can ignore it.
	if affectedRows == nil && strings.HasPrefix(commandTag, "INSERT ") {
		parts := strings.Split(commandTag, " ")
		if len(parts) != 3 {
			cn.bad = true
			errorf("unexpected INSERT command tag %s", commandTag)
		}
		affectedRows = &parts[len(parts)-1]
		commandTag = "INSERT"
	}
	// There should be no affected rows attached to the tag, just return it
	if affectedRows == nil {
		return driver.RowsAffected(0), commandTag
	}
	n, err := strconv.ParseInt(*affectedRows, 10, 64)
	if err != nil {
		cn.bad = true
		errorf("could not parse commandTag: %s", err)
	}
	return driver.RowsAffected(n), commandTag
}

// When doInsert is true, add the row to the table.
// When doInsert is false do prep-work and error checking, but don't
// actually add the row to the table.
func (s *fakeStmt) execInsert(args []driver.NamedValue, doInsert bool) (driver.Result, error) {
	db := s.c.db
	if len(args) != s.placeholders {
		panic("error in pkg db; should only get here if size is correct")
	}
	db.mu.Lock()
	t, ok := db.table(s.table)
	db.mu.Unlock()
	if !ok {
		return nil, fmt.Errorf("fakedb: table %q doesn't exist", s.table)
	}

	t.mu.Lock()
	defer t.mu.Unlock()

	var cols []interface{}
	if doInsert {
		cols = make([]interface{}, len(t.colname))
	}
	argPos := 0
	for n, colname := range s.colName {
		colidx := t.columnIndex(colname)
		if colidx == -1 {
			return nil, fmt.Errorf("fakedb: column %q doesn't exist or dropped since prepared statement was created", colname)
		}
		var val interface{}
		if strvalue, ok := s.colValue[n].(string); ok && strings.HasPrefix(strvalue, "?") {
			if strvalue == "?" {
				val = args[argPos].Value
			} else {
				// Assign value from argument placeholder name.
				for _, a := range args {
					if a.Name == strvalue[1:] {
						val = a.Value
						break
					}
				}
			}
			argPos++
		} else {
			val = s.colValue[n]
		}
		if doInsert {
			cols[colidx] = val
		}
	}

	if doInsert {
		t.rows = append(t.rows, &row{cols: cols})
	}
	return driver.RowsAffected(1), nil
}

func (s *driverStmt) Exec(args []driver.Value) (res driver.Result, err error) {
	cres := s.exec(args)
	if err = resultError(cres); err != nil {
		C.PQclear(cres)
		return
	}
	defer C.PQclear(cres)
	rowsAffected, err := strconv.ParseInt(C.GoString(C.PQcmdTuples(cres)), 10, 64)
	if err != nil {
		return
	}
	return driver.RowsAffected(rowsAffected), nil
}

func (s *stmt) q(args []driver.Value) (driver.Rows, driver.Result, error) {
	cmd, err := ado.NewCommand()
	if err != nil {
		return nil, nil, err
	}
	defer cmd.Release()
	err = cmd.PutrefActiveADOConnection(s.c.db)
	if err != nil {
		return nil, nil, err
	}

	err = cmd.PutCommandText(s.query)
	if err != nil {
		return nil, nil, err
	}
	err = cmd.PutCommandType(1)
	if err != nil {
		return nil, nil, err
	}

	params, err := cmd.GetParameters()
	if err != nil {
		return nil, nil, err
	}
	defer params.Release()

	for _, a := range args {
		var param *ado.Parameter
		switch v := a.(type) {
		case int64:
			v32 := int32(v)
			if int64(v32) != v {
				return nil, nil, fmt.Errorf("integer too large to pass to FoxPro: %d", v)
			}
			param, err = cmd.CreateParameter("", ado.Integer, ado.ParamInput, 4, v32)
		case float64:
			param, err = cmd.CreateParameter("", ado.Double, ado.ParamInput, 8, v)
		case bool:
			param, err = cmd.CreateParameter("", ado.Boolean, ado.ParamInput, 1, v)
		case []byte:
			param, err = cmd.CreateParameter("", ado.BSTR, ado.ParamInput, uintptr(len(v)), string(v))
		case string:
			param, err = cmd.CreateParameter("", ado.BSTR, ado.ParamInput, uintptr(len(v)), v)
		case time.Time:
			param, err = cmd.CreateParameter("", ado.Date, ado.ParamInput, 8, v)
		default:
			err = fmt.Errorf("foxpro: parameters of type %T are not supported", a)
		}
		if err != nil {
			return nil, nil, err
		}
		defer param.Release()
		err = params.Append(param)
		if err != nil {
			return nil, nil, err
		}
	}

	var nRecords com.Variant
	recordset, err := cmd.Execute(&nRecords, nil, ado.OptionUnspecified)
	if err != nil {
		return nil, nil, err
	}
	return &rows{recordset}, driver.RowsAffected(nRecords.Val), nil
}

func parseComplete(s string) driver.Result {
	parts := strings.Split(s, " ")
	n, _ := strconv.ParseInt(parts[len(parts)-1], 10, 64)
	return driver.RowsAffected(n)
}