Golang toolkit.Println函数代码示例

func (c *Sample) GetSampleData() {
	tk.Println("Getting sample data..")
	availability := m.Availability{}
	data, _ := availability.GetData(176, c.SqlCtx)
	tk.Println(data)
	tk.Println("Process Complete")
}

func TestFreeQuery(t *testing.T) {
	t.Skip()
	c, e := prepareConnection()
	if e != nil {
		t.Errorf("Unable to connect %s \n", e.Error())
	}
	defer c.Close()

	csr, e := c.NewQuery().
		Command("freequery", toolkit.M{}.
			Set("syntax", "select name from tes where name like 'r%'")).
		Cursor(nil)

	if csr == nil {
		t.Errorf("Cursor not initialized", e.Error())
		return
	}
	defer csr.Close()

	results := make([]map[string]interface{}, 0)
	err := csr.Fetch(&results, 0, false)
	if err != nil {
		t.Errorf("Unable to fetch: %s \n", err.Error())
	} else {
		toolkit.Println("======================")
		toolkit.Println("TEST FREE QUERY")
		toolkit.Println("======================")
		toolkit.Println("Fetch N OK. Result: ")
		for _, val := range results {
			toolkit.Printf("%v \n",
				toolkit.JsonString(val))
		}
	}
}

func TestOdbc(t *testing.T) {
	conn, e := odbc.Connect("DSN=mysql-dsn;UID=root;PWD=root")
	if e != nil {
		toolkit.Println("Conn Error found: ", e.Error())
	}
	toolkit.Println(conn)
	query := "SELECT id, name FROM dummy"
	stmt, e := conn.Prepare(query)
	if e != nil {
		toolkit.Println("STMT Error found: ", e.Error())
	}
	// toolkit.Println(conn, stmt)
	e = stmt.Execute()
	if e != nil {
		toolkit.Println("Execute Error found: ", e.Error())
	}

	rows, e := stmt.FetchAll()
	if e != nil {
		toolkit.Println("FetchAll Error found: ", e.Error())
	}
	// toolkit.Println(toolkit.JsonString(rows))
	for _, row := range rows {
		toolkit.Printf("%v\n", row.Data)
	}

	stmt.Close()
	conn.Close()
}

func (c *Sample) InsertSampleData() {
	tk.Println("Starting Insert sample data..")
	e := c.ConvertMGOToSQLServer(new(m.Availability))
	if e != nil {
		tk.Println(e)
	}
	tk.Println("Process Complete")
}

// Generate ...
func (d *GenWOListSummary) Generate() {
	tk.Println("##Generating Summary Data..")
	e := d.generateDurationIntervalSummary()
	if e != nil {
		tk.Println(e)
	}
	tk.Println("##Summary Data : DONE\n")
}

func main() {
	tk.Println("Starting the app..")
	mongo, e := PrepareConnection("mongo")
	if e != nil {
		tk.Println(e)
	}
	ctx = orm.New(mongo)
	GetStructFromCollection("ValueEquation_Dashboard")
	defer ctx.Close()
}

// Generate
func (s *GenPreventiveCorrectiveSummary) Generate(base *BaseController) {
	if base != nil {
		s.BaseController = base
	}

	tk.Println("##Generating PreventiveCorrectiveSummary..")
	e := s.generatePreventiveCorrectiveSummary()
	if e != nil {
		tk.Println(e)
	}
	tk.Println("##PreventiveCorrectiveSummary : DONE\n")
}

func TestConnect(t *testing.T) {
	t.Skip()
	c, e := prepareConnection()
	if e != nil {
		t.Errorf("Unable to connect: %s \n", e.Error())
		toolkit.Println(e)
	} else {
		toolkit.Println("###########################")
		toolkit.Println("Horay, connection success!")
		toolkit.Println("###########################")
	}
	defer c.Close()
}

// Generate Do the generate process
func (d *GenPlantMaster) Generate(base *BaseController) {
	if base != nil {
		d.BaseController = base
	}

	tk.Println("##Generating Plant Master..")
	e := d.generatePlantMaster()
	if e != nil {
		tk.Println(e)
	}

	tk.Println("##Plant Master : DONE\n")
}

func (m *MigrateData) DoGenerateDataBrowserFields() error {
	tStart := time.Now()
	tk.Println("Starting DoGenerateDataBrowserFields..")
	mod := new(DataBrowserFields)

	c, e := m.BaseController.MongoCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)

	if e != nil {
		return e
	}

	defer c.Close()

	result := []tk.M{}
	e = c.Fetch(&result, 0, false)

	for _, val := range result {
		selectedFields := val.Get("Fields")
		if nil != selectedFields {
			fields := selectedFields.(interface{}).([]interface{})
			for _, field := range fields {
				for {
					v := reflect.ValueOf(field)
					x := v.Interface()
					details := x.(tk.M)

					newVal := tk.M{}
					newVal.Set("FieldsReference", val.Get("_id"))
					newVal.Set("Alias", details["alias"])
					newVal.Set("Field", details["field"])
					newVal.Set("Type", details["tipe"])

					_, e := m.InsertOut(newVal, new(DataBrowserFields))
					if e == nil {
						break
					} else {
						tk.Println(e.Error())
						m.SqlCtx.Connection.Connect()
					}
				}
			}
		}
	}

	cr, e := m.BaseController.SqlCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
	ctn := cr.Count()
	cr.Close()

	tk.Printf("Completed Success in %v | %v data(s)\n", time.Since(tStart), ctn)
	return nil
}

func TestSelect(t *testing.T) {
	// t.Skip()
	skipIfConnectionIsNil(t)

	cursor, e := ctx.NewQuery().
		Select("id", "nama", "amount").
		From(tableName).
		Where(dbox.And(dbox.Gt("amount", 150), dbox.Eq("nama", "buku"))).
		// Where(dbox.Contains("nama", "tem", "pe")).
		// Order("nama").
		// Skip(2).
		// Take(1).
		Cursor(nil)
	// Where(dbox.And(dbox.Gt("price", "@price"), dbox.Eq("status", "@status"))).
	// Cursor(toolkit.M{}.Set("@price", 100000).Set("@status", "available"))
	// Where(dbox.And(dbox.Or(dbox.Eq("nama", "@name1"), dbox.Eq("nama", "@name2"),
	// dbox.Eq("nama", "@name3")), dbox.Lt("quantity", "@quantity"))).
	// Cursor(toolkit.M{}.Set("@name1", "buku").Set("@name2", "tas").
	// Set("@name3", "dompet").Set("@quantity", 4))
	if e != nil {
		t.Fatalf("Cursor error: " + e.Error())
	}
	defer cursor.Close()

	var results []toolkit.M
	e = cursor.Fetch(&results, 0, false)

	operation = "Test Select Filter"
	sintaks = `
		ctx.NewQuery().
		Select("id", "nama", "amount").
		From(tableName).
		Where(dbox.And(dbox.Gt("amount", 150000), 
			dbox.Eq("nama", "buku"))).
		Cursor(nil)`

	if e != nil {
		t.Errorf("Unable to fetch: %s \n", e.Error())
	} else {
		toolkit.Println("======================")
		toolkit.Println(operation)
		toolkit.Println("======================")
		toolkit.Println(sintaks)
		toolkit.Println("Fetch OK. Result:")
		for _, val := range results {
			toolkit.Printf("%v \n",
				toolkit.JsonString(val))
		}
	}
}

func (c *Connection) OnQuery(query string, name string) []string {
	var astr = []string{}

	rows, e := c.Sql.Query(query)
	if e != nil {
		toolkit.Println(e.Error())
		return nil
	}

	defer rows.Close()
	columns, e := rows.Columns()
	if e != nil {
		toolkit.Println(e.Error())
		return nil
	}

	count := len(columns)

	tableData := []toolkit.M{}
	values := make([]interface{}, count)
	valuePtrs := make([]interface{}, count)

	for rows.Next() {
		for i := 0; i < count; i++ {
			valuePtrs[i] = &values[i]
		}

		rows.Scan(valuePtrs...)
		entry := toolkit.M{}

		for i, col := range columns {
			var v interface{}
			val := values[i]
			b, ok := val.([]byte)
			if ok {
				v = string(b)
			} else {
				v = val
			}
			entry.Set(strings.ToLower(col), v)
		}
		tableData = append(tableData, entry)
	}
	for _, val := range tableData {
		astr = append(astr, val[name].(string))
	}

	return astr

}

func TestSelectAggregate(t *testing.T) {
	t.Skip()
	skipIfConnectionIsNil(t)

	csr, e := ctx.NewQuery().
		Select("nama").
		// Aggr(dbox.AggrSum, 1, "Total Item").
		Aggr(dbox.AggrMax, "amount", "Max Amount").
		Aggr(dbox.AggrSum, "amount", "Total Amount").
		// Aggr(dbox.AggrAvr, "amount", "Average Amount").
		From(tableName).
		Group("nama").
		Order("-nama").
		Cursor(nil)
	if e != nil {
		t.Errorf("Cursor pre error: %s \n", e.Error())
		return
	}
	if csr == nil {
		t.Errorf("Cursor not initialized")
		return
	}
	defer csr.Close()

	results := make([]map[string]interface{}, 0)

	err := csr.Fetch(&results, 0, false)
	sintaks = `
		ctx.NewQuery().
		Select("nama").
		Aggr(dbox.AggrMax, "amount", "Max Amount").
		Aggr(dbox.AggrSum, "amount", "Total Amount").
		From(tableName).
		Group("nama").
		Order("-nama").
		Cursor(nil)`
	if err != nil {
		t.Errorf("Unable to fetch: %s \n", err.Error())
	} else {
		toolkit.Println("======================")
		toolkit.Println("QUERY AGGREGATION")
		toolkit.Println("======================")
		toolkit.Println("Fetch N OK. Result:")
		for _, val := range results {
			toolkit.Printf("%v \n",
				toolkit.JsonString(val))
		}
	}
}

// Generate ...
func (s *GenSummaryData) Generate(base *BaseController) {
	var (
		e error
	)
	if base != nil {
		s.BaseController = base
	}

	tk.Println("##Generating Summary Data..")
	e = s.generateSummaryData()
	if e != nil {
		tk.Println(e)
	}
	tk.Println("##Summary Data : DONE\n")
}

func (m *MigrateData) DoPowerPlantOutages() error {
	tStart := time.Now()
	tk.Println("Starting DoPowerPlantOutages..")
	mod := new(PowerPlantOutages)

	c, e := m.BaseController.MongoCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)

	if e != nil {
		return e
	}

	defer c.Close()

	result := []tk.M{}
	e = c.Fetch(&result, 0, false)

	for _, val := range result {
		details := val.Get("Details").(interface{}).([]interface{})
		val.Set("Details", nil)

		_, e := m.InsertOut(val, new(PowerPlantOutages))
		if e != nil {
			tk.Printf("\n----------- ERROR -------------- \n %v \n\n %#v \n-------------------------  \n", e.Error(), val)
			return e
		}
		id := val.GetString("_id")
		tk.Printf("%#v \n\n", id)

		for _, detail := range details {
			det := detail.(tk.M)
			det.Set("POId", id)
			tk.Println(det)
			_, e = m.InsertOut(det, new(PowerPlantOutagesDetails))
			if e != nil {
				tk.Printf("\n----------- ERROR -------------- \n %v \n\n %#v \n-------------------------  \n", e.Error(), det)
				return e
			}
		}
	}

	cr, e := m.BaseController.SqlCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
	ctn := cr.Count()
	cr.Close()

	tk.Printf("Completed Success in %v | %v data(s)\n", time.Since(tStart), ctn)
	return nil

}