func (mu *MysqlUser) GrantExists(db mysql.Conn) (bool, error) { rows, _, err := db.Query( "SHOW GRANTS FOR '%v'@'%v'", mu.Username, mu.Hostname, ) if err != nil { return false, err } if len(rows) == 0 { return false, nil } for _, row := range rows { grant := row.Str(0) // This regex hasn't been extensively tested but works in my local tests regex := fmt.Sprintf("GRANT ALL (.+) ON .%v.(.+) TO .%v.@.%v.", mu.Database, mu.Username, mu.Hostname) matched, err := regexp.MatchString(regex, grant) if err != nil { return false, err } if matched { return true, nil } } return false, nil }
func (m MySQLPlugin) fetchShowStatus(db mysql.Conn, stat map[string]float64) error { rows, _, err := db.Query("show /*!50002 global */ status") if err != nil { log.Fatalln("FetchMetrics (Status): ", err) return err } for _, row := range rows { if len(row) > 1 { variableName := string(row[0].([]byte)) if err != nil { log.Fatalln("FetchMetrics (Status Fetch): ", err) return err } stat[variableName], _ = atof(string(row[1].([]byte))) } else { log.Fatalln("FetchMetrics (Status): row length is too small: ", len(row)) } } if m.EnableExtended { err = fetchShowStatusBackwardCompatibile(stat) if err != nil { log.Fatalln("FetchExtendedMetrics (Status Fetch): ", err) } } return nil }
func (m MySQLPlugin) fetchProcesslist(db mysql.Conn, stat map[string]float64) error { rows, _, err := db.Query("SHOW PROCESSLIST") if err != nil { log.Fatalln("FetchMetrics (Processlist): ", err) return err } for k := range processState { stat[k] = 0 } for _, row := range rows { if len(row) > 1 { var state string if row[6] == nil { state = "NULL" } else { state = string(row[6].([]byte)) } parseProcesslist(state, &stat) } else { log.Fatalln("FetchMetrics (Processlist): row length is too small: ", len(row)) } } return nil }
func udpateMySqlCdrImportStatus(db mysql.Conn, uniqueid string, status int) (err error) { var query = fmt.Sprintf("UPDATE cdr SET import = %d WHERE uniqueid = '%s'", status, uniqueid) log.Tracef("update cdr status [%s].\n", query) _, _, err = db.Query(query) // return err }
func mysqlVersion(conn mysqlc.Conn) (uint, uint, uint, error) { rows, _, err := conn.Query("SELECT VERSION()") if err != nil { return 0, 0, 0, err } if len(rows) == 0 { return 0, 0, 0, fmt.Errorf("SELECT VERSION() returned an empty set") } versionString := rows[0].Str(0) version := strings.Split(versionString, ".") invalidVersionErr := fmt.Errorf("Invalid major.minor.patch in %q", versionString) if len(version) != 3 { return 0, 0, 0, invalidVersionErr } major, err := strconv.ParseUint(version[0], 10, 32) if err != nil { return 0, 0, 0, invalidVersionErr } minor, err := strconv.ParseUint(version[1], 10, 32) if err != nil { return 0, 0, 0, invalidVersionErr } patch, err := strconv.ParseUint(version[2], 10, 32) if err != nil { return 0, 0, 0, invalidVersionErr } return uint(major), uint(minor), uint(patch), nil }
// Dump the script to create the table func dumpCreateTable(w io.Writer, db mysql.Conn, table string) { fmt.Fprintf(w, "\n--\n") fmt.Fprintf(w, "-- Table structure for table `%s`\n", table) fmt.Fprintf(w, "--\n\n") fmt.Fprintf(w, "DROP TABLE IF EXISTS `%s`;\n", table) row, _, err := db.QueryFirst("SHOW CREATE TABLE `%s`", table) checkError(err) fmt.Fprintf(w, "%s;\n", row.Str(1)) }
func innodbStatus(m *MysqlIns, db mysql.Conn) ([]*MetaData, error) { status, _, err := db.QueryFirst("SHOW /*!50000 ENGINE */ INNODB STATUS") if err != nil { return nil, err } ctn := status.Str(2) rows := strings.Split(ctn, "\n") return parseInnodbStatus(m, rows) }
func (mydb *MysqlDatabase) CreateDatabase(db mysql.Conn) error { // IF NOT EXISTS isn't strictly necessary since we are checking // to make sure it doesn't exist first but it doesn't hurt. _, _, err := db.Query("CREATE DATABASE IF NOT EXISTS %v", mydb.Name) if err != nil { return err } mydb.Result.Changed = true return nil }
func del(db mysql.Conn, bag_id int, stuff_id int) { _, _, err := db.Query("delete from player_bag where bag_id=%d", bag_id) if err != nil { panic(err) } _, _, err = db.Query("delete from paladin where paladin_id=%d", stuff_id) if err != nil { panic(err) } fmt.Printf("delete %d, %d\n", bag_id, stuff_id) }
func serverVersion(conn mysqlc.Conn) (*version.Version, error) { rows, _, err := conn.Query("SELECT VERSION()") if err != nil { return nil, err } if len(rows) == 0 { return nil, fmt.Errorf("SELECT VERSION() returned an empty set") } return version.NewVersion(rows[0].Str(0)) }
// Get list of existing tables in database func getTables(db mysql.Conn) (tables []string) { tables = make([]string, 0) rows, _, err := db.Query("SHOW TABLES") checkError(err) for _, row := range rows { for k, _ := range row { tables = append(tables, row.Str(k)) } } return }
func QueryCheck(db mysql.Conn, sql string, params ...interface{}) ([]mysql.Row, mysql.Result) { rows, res, err := db.Query(sql) if err != nil { errlog.Error("QueryCheck =%s", sql) errlog.Error("QueryCheck err=%s", err.Error()) fmt.Println(sql) fmt.Println(err) os.Exit(1) } return rows, res }
func ProcessNum(db mysql.Conn, cfg *base.Cfg) (*model.MetaData, error) { sql := "SHOW PROCESSLIST" rows, _, err := db.Query(sql) if err != nil { return nil, err } monitorName := "process_nums" threadNum := len(rows) - 1 data := model.NewMetric(monitorName, cfg) data.SetValue(threadNum) return data, nil }
func queryByPath(w http.ResponseWriter, db mysql.Conn, pt string) { rows, res := checkedResult(db.Query("select full_result from risks_check_history where apk='%s' ORDER BY id DESC Limit 1", pt)) full_result := res.Map("full_result") for _, row := range rows { //fmt.Ffmt.Printlnf(w, fmt.Fprintf(w, "------[ %s 包含以下风险]---------\n%s\n", pt, row.Str(full_result), ) RightLine() } }
func (m MySQLPlugin) fetchShowInnodbStatus(db mysql.Conn, stat map[string]float64) error { row, _, err := db.QueryFirst("SHOW /*!50000 ENGINE*/ INNODB STATUS") if err != nil { log.Fatalln("FetchMetrics (InnoDB Status): ", err) return err } if len(row) > 0 { parseInnodbStatus(string(row[len(row)-1].([]byte)), &stat) } else { log.Fatalln("FetchMetrics (InnoDB Status): row length is too small: ", len(row)) } return nil }
func (m MySQLPlugin) fetchShowSlaveStatus(db mysql.Conn, stat map[string]float64) error { rows, res, err := db.Query("show slave status") if err != nil { log.Fatalln("FetchMetrics (Slave Status): ", err) return err } for _, row := range rows { idx := res.Map("Seconds_Behind_Master") Value := row.Int(idx) stat["Seconds_Behind_Master"] = float64(Value) } return nil }
// Get the column list for the SELECT, applying the select map // from config file. func getColumnListForSelect(db mysql.Conn, table string) string { columns := make([]string, 0) rows, res, err := db.Query("SHOW COLUMNS FROM `%s`", table) checkError(err) for _, row := range rows { column := row.Str(res.Map("Field")) replacement, ok := selectMap[table][column] if ok { column = fmt.Sprintf("%s AS `%s`", replacement, column) } columns = append(columns, column) } return strings.Join(columns, ", ") }
func deleteMySqlCelRecord(db mysql.Conn, uniqueid string) (err error) { if config.PurgeCelEvents == false { return nil } var query = fmt.Sprintf("DELETE FROM cel WHERE uniqueid = '%s' OR linkedid = '%s'", uniqueid, uniqueid) _, _, err = db.Query(query) log.Debugf("getMySqlCallDetails execute : [%s] .\n", query) if err != nil { log.Errorf("deleteMySqlCelRecord Failed delete record into cel table for uniqueid [%s].\n", uniqueid) } return err }
//Execute customize requests provisted by configuration file func executeCustomRequests(db mysql.Conn) (err error) { for i := range config.CleanupRequests { var query = config.CleanupRequests[i] if strings.Contains(strings.ToLower(query), "delete") == true { return errors.New("Using delete keyword is forbiden. Please check your configuration file(config.json)") } _, _, err = db.Query(query) if err != nil { return err } } return nil }
func (mydb *MysqlDatabase) DatabaseExists(db mysql.Conn) (bool, error) { rows, _, err := db.Query( "SELECT count(*) AS dbs FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '%v'", mydb.Name, ) if err != nil { return false, err } if len(rows) != 1 { return false, errors.New("Unexpected number of rows in DatabaseExists()") } if rows[0].Int(0) > 0 { return true, nil } return false, nil }
// Allocates a new transaction func NewTransaction(connection mysql.Conn, query TransactionQuery) (*Transaction, error) { if len(query.Columns) < 1 { return nil, transactionError{"Too few columns"} } sss := fmt.Sprintf("INSERT IGNORE INTO `%s`.`%s` (`%s`) VALUES (?%s)", query.Database, query.Table, strings.Join(query.Columns, "`, `"), strings.Repeat(", ?", len(query.Columns)-1)) ins, err := connection.Prepare(sss) if err != nil { return nil, err } trans, err := connection.Begin() if err != nil { return nil, err } return &Transaction{trans.Do(ins), trans, len(query.Columns)}, nil }
func (m MySQLPlugin) fetchShowVariables(db mysql.Conn, stat map[string]float64) error { rows, _, err := db.Query("SHOW VARIABLES") if err != nil { log.Fatalln("FetchMetrics (Variables): ", err) } for _, row := range rows { if len(row) > 1 { variableName := string(row[0].([]byte)) if err != nil { log.Println("FetchMetrics (Fetch Variables): ", err) } stat[variableName], _ = atof(string(row[1].([]byte))) } else { log.Fatalln("FetchMetrics (Variables): row length is too small: ", len(row)) } } return nil }
func (mu *MysqlUser) UserExists(db mysql.Conn) (bool, error) { rows, _, err := db.Query( "SELECT COUNT(*) FROM mysql.user WHERE User = '******' and Host = '%v' and Password = password('%v')", mu.Username, mu.Hostname, mu.Password, ) if err != nil { return false, err } if len(rows) != 1 { return false, errors.New("Unexpected number of rows in UserExists()") } if rows[0].Int(0) > 0 { return true, nil } return false, nil }
func SlaveStatus(db mysql.Conn, cfg *base.Cfg) ([]*model.MetaData, error) { isSlave := model.NewMetric("Is_slave", cfg) row, res, err := db.QueryFirst("SHOW SLAVE STATUS") if err != nil { return nil, err } // be master if row == nil { isSlave.SetValue(0) isSlave.Tags = fmt.Sprintf("%s,role=%s", isSlave.Tags, "master") return []*model.MetaData{isSlave}, nil } // be slave isSlave.SetValue(1) isSlave.Tags = fmt.Sprintf("%s,role=%s", isSlave.Tags, "slaver") data := make([]*model.MetaData, len(SlaveStatusToSend)) for i, s := range SlaveStatusToSend { data[i] = model.NewMetric(s, cfg) switch s { case "Slave_SQL_Running", "Slave_IO_Running": data[i].SetValue(0) v := row.Str(res.Map(s)) if v == "Yes" { data[i].SetValue(1) } default: v, err := row.Int64Err(res.Map(s)) if err != nil { data[i].SetValue(-1) } else { data[i].SetValue(v) } } } return append(data, isSlave), nil }
/** * Process selection CEL events for given unique id */ func getMySqlCel(db mysql.Conn, uniqueid string) (cel Cel, err error) { myCelQuery := "select UNIX_TIMESTAMP(eventtime) as eventtime from cel where eventtype LIKE 'ANSWER' AND linkedid!=uniqueid AND linkedid='" + uniqueid + "'" // rows, res, err := db.Query(myCelQuery) if err != nil { return cel, err } log.Tracef("getMySqlCel request executed and get [%d] rows\r\n", len(rows)) if len(rows) > 0 { log.Tracef("getMySqlCel get rows for uniqueid [%s]", uniqueid) row := rows[0] eventtime := res.Map("eventtime") cel.EventTime = row.Int64(eventtime) } else { log.Tracef("getMySqlCel faied to get rows for uniqueid [%s].", uniqueid) cel.EventTime = 0 } return cel, nil }
func mysqlState(m *MysqlIns, db mysql.Conn, sql string) ([]*MetaData, error) { rows, _, err := db.Query(sql) if err != nil { return nil, err } data := make([]*MetaData, len(rows)) i := 0 for _, row := range rows { key_ := row.Str(0) v, err := row.Int64Err(1) // Ignore non digital value if err != nil { continue } data[i] = NewMetric(key_) data[i].SetValue(v) i++ } return data[:i], nil }
func (m MySQLPlugin) FetchShowStatus(db mysql.Conn, stat map[string]float64) error { rows, _, err := db.Query("show /*!50002 global */ status") if err != nil { log.Fatalln("FetchMetrics (Status): ", err) return err } for _, row := range rows { if len(row) > 1 { Variable_name := string(row[0].([]byte)) if err != nil { log.Fatalln("FetchMetrics (Status Fetch): ", err) return err } //fmt.Println(Variable_name, Value) stat[Variable_name], _ = _atof(string(row[1].([]byte))) } else { log.Fatalln("FetchMetrics (Status): row length is too small: ", len(row)) } } return nil }
func slaveStatus(m *MysqlIns, db mysql.Conn) ([]*MetaData, error) { isSlave := NewMetric("Is_slave") row, res, err := db.QueryFirst("SHOW SLAVE STATUS") if err != nil { return nil, err } // be master if row == nil { isSlave.SetValue(0) return []*MetaData{isSlave}, nil } // be slave isSlave.SetValue(1) data := make([]*MetaData, len(SlaveStatusToSend)) for i, s := range SlaveStatusToSend { data[i] = NewMetric(s) switch s { case "Slave_SQL_Running", "Slave_IO_Running": data[i].SetValue(0) v := row.Str(res.Map(s)) if v == "Yes" { data[i].SetValue(1) } default: v, err := row.Int64Err(res.Map(s)) if err != nil { data[i].SetValue(-1) } else { data[i].SetValue(v) } } } return append(data, isSlave), nil }
func (this *DataModule) AccountloginToo(param *acc.LoginPlayer_MA, itbid int32, conn mysql.Conn) *AccParams { str := fmt.Sprintf(`set @iisfcm = %d`, 1) res, err := conn.Start(str) if err != nil { fmt.Println("存储过程调用失败", err.Error()) } str = fmt.Sprintf(`set @iserverid = %d`, 0) res, err = conn.Start(str) if err != nil { fmt.Println("存储过程调用失败", err.Error()) } str = fmt.Sprintf(`call mfxy_accountlogin(%d,'%s','%s','%s','%s',@iserverid,%d,%d,%d,@iisfcm,@ifcmtime,@iaccid,@igmlevel,@igamepoints,@szprotectques,@szprotectansw,@iretval)`, itbid, *param.SzAccount, *param.SzPassword, *param.SzIp, "haha", *param.ProductId, *param.PlatformId, *param.LoginType) fmt.Println(str) res, err = conn.Start(str) if err != nil { fmt.Println("存储过程调用失败", err.Error()) } str = fmt.Sprintf(`select @iserverid,@iisfcm,@ifcmtime,@iaccid,@igmlevel,@igamepoints,@szprotectques,@szprotectansw,@iretval`) fmt.Println(str) res, err = conn.Start(str) if err != nil { fmt.Println("存储过程调用失败", err.Error()) } row, _ := res.GetRow() repParams := new(AccParams) repParams.Serverid = uint64(row.Int(0)) repParams.Isfcm = uint32(row.Int(1)) repParams.Ifcmtime = uint64(row.Int64(2)) repParams.Accid = uint64(row.Int64(3)) repParams.Gmlevel = uint32(row.Int(4)) repParams.Points = uint64(row.Int(5)) repParams.Productid = uint64(row.Int64(6)) repParams.Protectansw = row.Str(7) repParams.Iretval = int32(row.Int(8)) fmt.Println("datamodul end") return repParams }
// Get the table data func dumpTableData(w io.Writer, db mysql.Conn, table string) { fmt.Fprintf(w, "\n--\n-- Dumping data for table `%s`\n--\n\n", table) rowCnt, _, err := db.QueryFirst(getSelectCountQueryFor(db, table)) checkError(err) if rowCnt.Int(0) == 0 { fmt.Fprintf(w, "--\n-- Empty table\n--\n\n") return } else { fmt.Fprintf(w, "--\n-- %d rows\n--\n\n", rowCnt.Int(0)) } fmt.Fprintf(w, "LOCK TABLES `%s` WRITE;\n", table) query := fmt.Sprintf("INSERT INTO `%s` VALUES", table) rows := make([]string, 0) res, err := db.Start(getSelectQueryFor(db, table)) checkError(err) row := res.MakeRow() for { err = res.ScanRow(row) if err == io.EOF { break } checkError(err) vals := make([]string, 0) for k, col := range row { val := "NULL" if col != nil { val = fmt.Sprintf("'%s'", db.EscapeString(row.Str(k))) } vals = append(vals, val) } rows = append(rows, fmt.Sprintf("( %s )", strings.Join(vals, ", "))) if len(rows) >= 100 { fmt.Fprintf(w, "%s\n%s;\n", query, strings.Join(rows, ",\n")) rows = make([]string, 0) } } if len(rows) > 0 { fmt.Fprintf(w, "%s\n%s;\n", query, strings.Join(rows, ",\n")) } fmt.Fprintf(w, "\nUNLOCK TABLES;\n") }