gota

package main

import (
    "fmt"
    "github.com/go-gota/gota/dataframe"
    "github.com/go-gota/gota/series"
    "github.com/qichengzx/coordtransform"
    "log"
    "os"
    "strconv"
)

func rApply(s series.Series) series.Series {
    id, _ := s.Elem(0).Int()
    lon, lat := coordTransform.WGS84toGCJ02(s.Elem(1).Float(), s.Elem(2).Float())
    return series.New([]string{
        strconv.FormatInt(int64(id), 10),
        strconv.FormatFloat(lon, 'f', 6, 64),
        strconv.FormatFloat(lat, 'f', 6, 64)},
        series.String, "row")
}

func cApply(s series.Series) series.Series {
    if s.Name == "id" {
        ids := []string{}
        leng := s.Len()
        for i := 0; i < leng; i++ {
            val, _ := s.Elem(i).Int()
            id_s := strconv.FormatInt(int64(val), 10)
            ids = append(ids, strconv.FormatInt(int64(i), 10)+"_"+id_s)
        }
        return series.Strings(ids)
    } else if s.Name == "lon" || s.Name == "lat" {
        lonlats := []string{}
        leng := s.Len()
        for i := 0; i < leng; i++ {
            val := s.Elem(i).Float()
            lonlat_s := strconv.FormatFloat(val, 'f', 6, 64)
            if s.Name == "lon" {
                lonlats = append(lonlats, "lon"+"_"+lonlat_s)
            } else {
                lonlats = append(lonlats, "lat"+"_"+lonlat_s)
            }
        }
        return series.Strings(lonlats)
    } else {
        panic("error")
    }

}
func main() {
    file, err := os.Open("/Users/xxx/Downloads/kmeans_result_table_7.csv")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    df := dataframe.ReadCSV(file)

    fmt.Println(df.Ncol())
    fmt.Println(df.Nrow())

    df2 := df.Select([]string{"id", "lon", "lat"})
    fmt.Println(df2)
    fmt.Println(df2.Types())

    df3 := df2.Rapply(rApply)
    fmt.Println(df3.Types())
    fmt.Println(df3)

    df4 := df2.Select([]string{"id", "lon", "lat"}).Capply(cApply)
    fmt.Println(df4.Types())
    fmt.Println(df4)

    filter := dataframe.F{
        Colname:    "lon",
        Comparator: series.Greater,
        Comparando: 136,
    }
    df5 := df2.Filter(filter)
    fmt.Println(df5)

    join := df2.LeftJoin(df4, "id")
    fmt.Println(join)

    lon_02 := df3.Col("X1")
    df6 := df2.Mutate(lon_02).Rename("lon_02","X1")
    fmt.Println(df6)

}

package main

import (
    "fmt"
    "github.com/go-gota/gota/dataframe"
    "github.com/go-gota/gota/series"
    "github.com/go-xorm/xorm"
    "log"
    "reflect"
)

func main() {
    conn := "postgres://user:pw@host:port/dbname?sslmode=disable;" // 第一个默认是master
    engine, err := xorm.NewEngine("postgres", conn)
    if err != nil {
        log.Fatal("数据库连接失败:", err)
    }
    defer engine.Close()
    sql_0214 := `select road_id,hn_id,path_name,ad_name || path_name as name 
                    from poi_hn_road_0214 limit 1000`
    sql := `select road_id,hn_id,path_name,ad_name || path_name as name
                    from poi_hn_road limit 1000`

    rows0214, err := engine.QueryString(sql_0214)
    rows, err := engine.QueryString(sql)
    if err != nil {
        log.Fatal("数据库查询失败:", err)
    }
    fmt.Println("len(rows)", len(rows), reflect.TypeOf(rows))

    records0214 := [][]string{}
    records := [][]string{}
    for _, row := range rows0214 {
        rowList := []string{row["road_id"], row["hn_id"], row["path_name"], row["name"]}
        records0214 = append(records0214, rowList)
    }
    for _, row := range rows {
        rowList := []string{row["road_id"], row["hn_id"], row["path_name"], row["name"]}
        records = append(records, rowList)
    }

    columns := []string{"road_id", "hn_id", "path_name", "name"}
    column_types := map[string]series.Type{}
    for _, column := range columns {
        column_types[column] = series.String
    }

    df0214 := dataframe.LoadRecords(records0214, dataframe.HasHeader(false),
        dataframe.Names(columns...),
        dataframe.WithTypes(column_types))
    df := dataframe.LoadRecords(records, dataframe.HasHeader(false),
        dataframe.Names(columns...),
        dataframe.WithTypes(column_types))
    fmt.Println(df0214)
    fmt.Println(df)

    joinedDf := df0214.LeftJoin(df, "name")
    fmt.Println(joinedDf)
    v := joinedDf.Elem(0, 5)
    fmt.Println(joinedDf.Elem(0, 5), reflect.TypeOf(v))

    filter := dataframe.F{
        Colname:    "road_id_1",
        Comparator: series.CompFunc,
        Comparando: func(a interface{}) func(el series.Element) bool {
            return func(el series.Element) bool {
                return el.Val() != nil
            }
        }(nil),
    }

    filter_df := joinedDf.Filter(filter)
    fmt.Println(filter_df)
}