// String lower function
// must be able to convert to string
//
func Lower(ctx expr.EvalContext, item value.Value) (value.StringValue, bool) {
val, ok := value.ToString(item.Rv())
if !ok {
return value.EmptyStringValue, false
}
return value.NewStringValue(strings.ToLower(val)), true
}
// Extract host from a String (must be urlish), doesn't do much/any validation
func Qs(ctx expr.EvalContext, urlItem, keyItem value.Value) (value.StringValue, bool) {
val, ok := value.ToString(urlItem.Rv())
if !ok {
return value.EmptyStringValue, false
}
if val == "" {
return value.EmptyStringValue, false
}
urlstr := strings.ToLower(val)
if len(urlstr) < 8 {
return value.EmptyStringValue, false
}
keyVal, ok := value.ToString(keyItem.Rv())
if !ok {
return value.EmptyStringValue, false
}
if keyVal == "" {
return value.EmptyStringValue, false
}
if !strings.HasPrefix(urlstr, "http") {
urlstr = "http://" + urlstr
}
if urlParsed, err := url.Parse(urlstr); err == nil {
//u.Infof("url.parse: %#v", urlParsed)
qsval, ok := urlParsed.Query()[keyVal]
if !ok {
return value.EmptyStringValue, false
}
if len(qsval) > 0 {
return value.NewStringValue(qsval[0]), true
}
}
return value.EmptyStringValue, false
}
// Not: urnary negation function
//
// eq(item,5)
func NotFunc(ctx expr.EvalContext, item value.Value) (value.BoolValue, bool) {
boolVal, ok := value.ToBool(item.Rv())
if ok {
return value.NewBoolValue(!boolVal), true
}
return value.BoolValueFalse, false
}
// <= Less Than or Equal
// Must be able to convert items to Floats or else not ok
//
func LeFunc(ctx expr.EvalContext, lv, rv value.Value) (value.BoolValue, bool) {
left, _ := value.ToFloat64(lv.Rv())
right, _ := value.ToFloat64(rv.Rv())
if math.IsNaN(left) || math.IsNaN(right) {
return value.BoolValueFalse, false
}
return value.NewBoolValue(left <= right), true
}
// < Less Than
// Must be able to convert items to Floats or else not ok
//
func LtFunc(ctx expr.EvalContext, lv, rv value.Value) (value.BoolValue, bool) {
left := value.ToFloat64(lv.Rv())
right := value.ToFloat64(rv.Rv())
if left == math.NaN() || right == math.NaN() {
return value.BoolValueFalse, false
}
return value.NewBoolValue(left < right), true
}
// Example of a custom Function, that we are adding into the Expression VM
//
// select
// user_id AS theuserid, email, item_count * 2, reg_date
// FROM stdio
// WHERE email_is_valid(email)
func EmailIsValid(ctx expr.EvalContext, email value.Value) (value.BoolValue, bool) {
emailstr, ok := value.ToString(email.Rv())
if !ok || emailstr == "" {
return value.BoolValueFalse, true
}
if _, err := mail.ParseAddress(emailstr); err == nil {
return value.BoolValueTrue, true
}
return value.BoolValueFalse, true
}
// todate
func ToDate(ctx expr.EvalContext, item value.Value) (value.TimeValue, bool) {
dateStr, ok := value.ToString(item.Rv())
if !ok {
return value.TimeZeroValue, false
}
//u.Infof("v=%v %v ", v, item.Rv())
if t, err := dateparse.ParseAny(dateStr); err == nil {
return value.NewTimeValue(t), true
}
return value.TimeZeroValue, false
}
// totimestamp: convert to date, then to unix Seconds
//
func ToTimestamp(ctx expr.EvalContext, item value.Value) (value.IntValue, bool) {
dateStr, ok := value.ToString(item.Rv())
if !ok {
return value.NewIntValue(0), false
}
if t, err := dateparse.ParseAny(dateStr); err == nil {
//u.Infof("v=%v %v unix=%v", item, item.Rv(), t.Unix())
return value.NewIntValue(int64(t.Unix())), true
}
return value.NewIntValue(0), false
}
// String contains
// Will first convert to string, so may get unexpected results
//
func ContainsFunc(ctx expr.EvalContext, lv, rv value.Value) (value.BoolValue, bool) {
left, leftOk := value.ToString(lv.Rv())
right, rightOk := value.ToString(rv.Rv())
if !leftOk || !rightOk {
return value.BoolValueFalse, false
}
//u.Infof("Contains(%v, %v)", left, right)
if left == "" || right == "" {
return value.BoolValueFalse, false
}
if strings.Contains(left, right) {
return value.BoolValueTrue, true
}
return value.BoolValueFalse, true
}
// Split a string, accepts an optional with parameter
//
// split(item, ",")
//
func SplitFunc(ctx expr.EvalContext, input value.Value, splitByV value.StringValue) (value.StringsValue, bool) {
sv, ok := value.ToString(input.Rv())
splitBy, splitByOk := value.ToString(splitByV.Rv())
if !ok || !splitByOk {
return value.NewStringsValue(make([]string, 0)), false
}
if sv == "" {
return value.NewStringsValue(make([]string, 0)), false
}
if splitBy == "" {
return value.NewStringsValue(make([]string, 0)), false
}
vals := strings.Split(sv, splitBy)
return value.NewStringsValue(vals), true
}
// Pow
func PowFunc(ctx EvalContext, val, toPower value.Value) (value.NumberValue, bool) {
//Pow(x, y float64) float64
//u.Infof("powFunc: %T:%v %T:%v ", val, val.Value(), toPower, toPower.Value())
if val.Err() || val.Nil() {
return value.NewNumberValue(0), false
}
if toPower.Err() || toPower.Nil() {
return value.NewNumberValue(0), false
}
fv, pow := value.ToFloat64(val.Rv()), value.ToFloat64(toPower.Rv())
if fv == math.NaN() || pow == math.NaN() {
return value.NewNumberValue(0), false
}
fv = math.Pow(fv, pow)
//u.Infof("pow ??? vals=[%v]", fv, pow)
return value.NewNumberValue(fv), true
}
// emailname a string, parses email
//
// emailname("Bob <*****@*****.**>") => Bob
//
func EmailNameFunc(ctx expr.EvalContext, item value.Value) (value.StringValue, bool) {
val, ok := value.ToString(item.Rv())
if !ok {
return value.EmptyStringValue, false
}
if val == "" {
return value.EmptyStringValue, false
}
if len(val) < 6 {
return value.EmptyStringValue, false
}
if em, err := mail.ParseAddress(val); err == nil {
return value.NewStringValue(em.Name), true
}
return value.EmptyStringValue, false
}
func Yy(ctx expr.EvalContext, item value.Value) (value.IntValue, bool) {
//u.Info("yy: %T", item)
val, ok := value.ToString(item.Rv())
if !ok || val == "" {
return value.NewIntValue(0), false
}
//u.Infof("v=%v %v ", val, item.Rv())
if t, err := dateparse.ParseAny(val); err == nil {
yy := t.Year()
if yy >= 2000 {
yy = yy - 2000
} else if yy >= 1900 {
yy = yy - 1900
}
//u.Infof("Yy = %v yy = %v", item, yy)
return value.NewIntValue(int64(yy)), true
}
return value.NewIntValue(0), false
}
// email a string, parses email
//
// email("Bob <*****@*****.**>") => [email protected]
//
func EmailDomainFunc(ctx expr.EvalContext, item value.Value) (value.StringValue, bool) {
val, ok := value.ToString(item.Rv())
if !ok {
return value.EmptyStringValue, false
}
if val == "" {
return value.EmptyStringValue, false
}
if len(val) < 6 {
return value.EmptyStringValue, false
}
if em, err := mail.ParseAddress(strings.ToLower(val)); err == nil {
parts := strings.SplitN(strings.ToLower(em.Address), "@", 2)
if len(parts) == 2 {
return value.NewStringValue(parts[1]), true
}
}
return value.EmptyStringValue, false
}
// urlminusqs removes a specific query parameter and its value from a url
//
// urlminusqs("http://www.lytics.io/?q1=google&q2=123", "q1") => "http://www.lytics.io/?q2=123", true
//
func UrlMinusQs(ctx expr.EvalContext, urlItem, keyItem value.Value) (value.StringValue, bool) {
val := ""
switch itemT := urlItem.(type) {
case value.StringValue:
val = itemT.Val()
case value.StringsValue:
if len(itemT.Val()) == 0 {
return value.EmptyStringValue, false
}
val = itemT.Val()[0]
}
if val == "" {
return value.EmptyStringValue, false
}
if !strings.HasPrefix(val, "http") {
val = "http://" + val
}
keyVal, ok := value.ToString(keyItem.Rv())
if !ok {
return value.EmptyStringValue, false
}
if keyVal == "" {
return value.EmptyStringValue, false
}
if up, err := url.Parse(val); err == nil {
qsval := up.Query()
_, ok := qsval[keyVal]
if !ok {
return value.NewStringValue(fmt.Sprintf("%s://%s%s?%s", up.Scheme, up.Host, up.Path, up.RawQuery)), true
}
qsval.Del(keyVal)
up.RawQuery = qsval.Encode()
if up.RawQuery == "" {
return value.NewStringValue(fmt.Sprintf("%s://%s%s", up.Scheme, up.Host, up.Path)), true
}
return value.NewStringValue(fmt.Sprintf("%s://%s%s?%s", up.Scheme, up.Host, up.Path, up.RawQuery)), true
}
return value.EmptyStringValue, false
}
// Extract url path from a String (must be urlish), doesn't do much/any validation
func UrlPath(ctx expr.EvalContext, item value.Value) (value.StringValue, bool) {
val, ok := value.ToString(item.Rv())
if !ok {
return value.EmptyStringValue, false
}
if val == "" {
return value.EmptyStringValue, false
}
urlstr := strings.ToLower(val)
if len(urlstr) < 8 {
return value.EmptyStringValue, false
}
if !strings.HasPrefix(urlstr, "http") {
urlstr = "http://" + urlstr
}
if urlParsed, err := url.Parse(urlstr); err == nil {
//u.Infof("url.parse: %#v", urlParsed)
return value.NewStringValue(urlParsed.Path), true
}
return value.EmptyStringValue, false
}
// Equal function? returns true if items are equal
//
// eq(item,5)
func Eq(e *State, itemA, itemB value.Value) (value.BoolValue, bool) {
//return BoolValue(itemA == itemB)
rvb := value.CoerceTo(itemA.Rv(), itemB.Rv())
//u.Infof("Eq(): a:%T b:%T %v=%v?", itemA, itemB, itemA.Value(), rvb)
return value.NewBoolValue(reflect.DeepEqual(itemA.Rv(), rvb)), true
}