Esempio n. 1
0
func (self *table) get(key string) (ret []byte, err error) {
	if len(key) > keylen {
		return nil, fmt.Errorf("key (%s) len must <= 64", key)
	}

	defer self.tableStats.Record("get", time.Now())
	hid := makeHash(key)

	if self.caches != nil {
		cidx := self.getCacheNode(hid)
		cache := cidx.Get()
		defer cache.Recycle()

		ret, err = redis.Bytes(cache.Conn.Do("GET", self.name+"_"+key))
		//fmt.Print("GET ", self.name+"_"+key, "\n")
		if err != nil {

			if err != redis.ErrNil {
				logger.Fatal("get error: %s (%s, %v)", err.Error(), key, ret)
			} else {
				err = nil
			}
		}

		if ret != nil {
			return
		}
	}

	if self.dbs != nil {
		didx := self.getDbNode(hid)
		db := didx.Get()
		defer db.Recycle()

		var rows *sql.Rows
		rows, err = db.Query("SELECT body from "+self.name+" where id = CAST(? as BINARY(64)) LIMIT 1;", key)

		if err != nil {
			logger.Fatal("get error: %s (%s, %v)", err.Error(), key, rows)
		}

		defer rows.Close()

		for rows.Next() {
			err = rows.Scan(&ret)
			if err != nil {
				logger.Fatal("get scan error %s (%s)", err.Error(), key)
			}
			return
		}
	}

	return nil, nil
}
Esempio n. 2
0
func (self *table) del(key string) (err error) {
	if len(key) > keylen {
		return fmt.Errorf("key (%s) len must <= 64", key)
	}

	defer self.tableStats.Record("del", time.Now())
	hid := makeHash(key)

	if self.caches != nil {
		cidx := self.getCacheNode(hid)
		cache := cidx.Get()
		defer cache.Recycle()

		_, err = cache.Conn.Do("DEL", self.name+"_"+key)

		if err != nil {
			if err != redis.ErrNil {
				logger.Fatal("del error: %s (%s)", err.Error(), key)
			} else {
				err = nil
			}
		}
	}

	if self.dbs != nil {
		didx := self.getDbNode(hid)
		db := didx.Get()
		defer db.Recycle()

		_, err = db.Query("DELETE from "+self.name+" where id = CAST(? as BINARY(64));", key)

		if err != nil {
			logger.Fatal("delete error: %s (%s)", err.Error(), key)
		}
	}

	return
}
Esempio n. 3
0
func (self *table) write(key string, value []byte) (err error) {
	if len(key) > keylen {
		return fmt.Errorf("key (%s) len must <= 64", key)
	}

	defer self.tableStats.Record("write", time.Now())
	hid := makeHash(key)

	if self.caches != nil {
		cidx := self.getCacheNode(hid)
		cache := cidx.Get()
		defer cache.Recycle()

		_, err = cache.Conn.Do("SET", self.name+"_"+key, value)
		//fmt.Print("SET ", self.name+"_"+key, " : ",value, "\n")

		if err != nil {
			logger.Fatal("write error: %s (%s, %v)", err.Error(), key, value)
		}
	}

	if self.dbs != nil {
		didx := self.getDbNode(hid)
		db := didx.Get()
		defer db.Recycle()

		_, err = db.Exec("INSERT INTO "+self.name+" (id, body) values(?, ?) ON DUPLICATE KEY UPDATE body=?;", key, value, value)
		//_, err = db.Exec("REPLACE INTO "+self.name+" (id, body) values(?, ?);", key, value)

		if err != nil {
			logger.Fatal("write error: %s (%s, %v)", err.Error(), key, value)
		}
	}

	return
}
Esempio n. 4
0
func NewTable(name string, cfg config.TableConfig, server *DBServer) (t *table) {
	var (
		caches       cacheGroup
		cacheNode    []uint32
		dbs          dbGroup
		dbNode       []uint32
		dbVirNode    map[uint32]uint32
		cacheVirNode map[uint32]uint32
	)
	if cfg.CacheProfile != "" {
		var exist bool
		if caches, exist = server.cacheGroups[cfg.CacheProfile]; !exist {
			logger.Fatal("NewTable: table cache profile not found: %s", cfg.CacheProfile)
		}
		cacheNode, _ = server.cacheNodes[cfg.CacheProfile]
		cacheVirNode, _ = server.cacheVirNodes[cfg.CacheProfile]
	}

	if cfg.DBProfile != "" {
		var exist bool
		if dbs, exist = server.dbGroups[cfg.DBProfile]; !exist {
			logger.Fatal("NewTable: table db profile not found: %s", cfg.DBProfile)
		}
		dbNode, _ = server.dbNodes[cfg.DBProfile]
		dbVirNode, _ = server.dbVirNodes[cfg.DBProfile]
		for _, dbpool := range dbs {
			db := dbpool.Get()
			defer db.Recycle()
			/*
				query := fmt.Sprintf(`
						CREATE TABLE IF NOT EXISTS %s (
					    added_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
					    id BINARY(32) NOT NULL,
					    body MEDIUMBLOB,
					    updated TIMESTAMP NOT NULL,
					    UNIQUE KEY (id),
					    KEY (updated)
					) ENGINE=InnoDB;
					`, name)
			*/

			query := fmt.Sprintf(`
					CREATE TABLE IF NOT EXISTS %s (
				    id BINARY(64) NOT NULL PRIMARY KEY,
					auto_id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
				    body MEDIUMBLOB,
				    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
				    KEY (updated),
					key (auto_id)
				) ENGINE=InnoDB;
				`, name)

			logger.Info("CreateQuery :%s", query)
			rst, err := db.Exec(
				query,
			)

			if err != nil {
				logger.Fatal("NewTable: db %v create table %s faild! %s", dbpool, name, err.Error())
			}

			logger.Info("NewTable: db %v init %s: %v", dbpool, name, rst)

		}
	}

	if caches == nil && dbs == nil {
		logger.Fatal("NewTable: table %s need a save func", name)
	}

	queryStats := stats.NewTimings("")
	qpsRates := stats.NewRates("", queryStats, 20, 10e9)
	return &table{
		name, caches, dbs,
		cfg.DeleteExpiry,
		queryStats,
		qpsRates,
		cacheNode,
		dbNode,
		dbVirNode,
		cacheVirNode,
	}
}