tranfi 0.1.2 → 0.2.1

package/csrc/expr.c

@@ -11,7 +11,7 @@
  *   add_expr = mul_expr (('+' | '-') mul_expr)*
  *   mul_expr = unary (('*' | '/') unary)*
  *   unary    = '-' unary | atom
- *   atom     = NUMBER | STRING | col_ref | '(' expr ')'
+ *   atom     = NUMBER | STRING | BOOL | col_ref | '(' expr ')'
  *   col_ref  = 'col(' STRING ')'
  *   NUMBER   = [0-9]+('.'[0-9]+)?
  *   STRING   = '\'' [^']* '\'' | '"' [^"]* '"'
@@ -35,6 +35,7 @@ typedef struct {
     const char *src;
     size_t      pos;
     size_t      len;
+    int         depth_error;
 } parser_state;
 
 static void skip_ws(parser_state *p) {
@@ -91,7 +92,15 @@ static void consume_cmp_op(parser_state *p, cmp_op op) {
 
 /* ---- Recursive descent parser ---- */
 
-static tf_expr *parse_expr(parser_state *p);
+#define TF_EXPR_MAX_DEPTH 256
+
+static tf_expr *parse_expr_d(parser_state *p, unsigned depth);
+
+static int expr_depth_exceeded(parser_state *p, unsigned depth) {
+    if (depth <= TF_EXPR_MAX_DEPTH) return 0;
+    p->depth_error = 1;
+    return 1;
+}
 
 static tf_expr *make_expr(expr_kind kind) {
     tf_expr *e = calloc(1, sizeof(tf_expr));
@@ -115,7 +124,16 @@ static tf_expr *parse_string_literal(parser_state *p) {
 
     tf_expr *e = make_expr(EXPR_LIT_STR);
     if (!e) return NULL;
-    e->lit_str = malloc(slen + 1);
+    size_t alloc_len = 0;
+    if (tf_size_add(slen, 1, &alloc_len) != TF_OK) {
+        tf_expr_free(e);
+        return NULL;
+    }
+    e->lit_str = tf_mallocarray_checked(alloc_len, sizeof(char));
+    if (!e->lit_str) {
+        tf_expr_free(e);
+        return NULL;
+    }
     memcpy(e->lit_str, p->src + start, slen);
     e->lit_str[slen] = '\0';
     return e;
@@ -124,10 +142,10 @@ static tf_expr *parse_string_literal(parser_state *p) {
 /* Parse a comma-separated argument list inside parentheses.
  * Assumes '(' has already been consumed. Consumes the closing ')'.
  * Returns allocated array of expressions, sets *n_args. */
-static tf_expr **parse_arg_list(parser_state *p, int *n_args) {
+static tf_expr **parse_arg_list(parser_state *p, int *n_args, unsigned depth) {
     *n_args = 0;
-    int cap = 4;
-    tf_expr **args = malloc(cap * sizeof(tf_expr *));
+    size_t cap = 4;
+    tf_expr **args = tf_mallocarray_checked(cap, sizeof(tf_expr *));
     if (!args) return NULL;
 
     skip_ws(p);
@@ -138,13 +156,20 @@ static tf_expr **parse_arg_list(parser_state *p, int *n_args) {
     }
 
     for (;;) {
-        tf_expr *arg = parse_expr(p);
+        tf_expr *arg = parse_expr_d(p, depth);
         if (!arg) goto fail;
-        if (*n_args >= cap) {
-            cap *= 2;
-            tf_expr **na = realloc(args, cap * sizeof(tf_expr *));
+        if ((size_t)*n_args >= cap) {
+            size_t need = 0;
+            size_t new_cap = 0;
+            if (tf_size_add((size_t)*n_args, 1, &need) != TF_OK ||
+                tf_size_grow_pow2(cap, need, 4, &new_cap) != TF_OK) {
+                tf_expr_free(arg);
+                goto fail;
+            }
+            tf_expr **na = tf_reallocarray_checked(args, new_cap, sizeof(tf_expr *));
             if (!na) { tf_expr_free(arg); goto fail; }
             args = na;
+            cap = new_cap;
         }
         args[(*n_args)++] = arg;
         skip_ws(p);
@@ -164,14 +189,15 @@ fail:
     return NULL;
 }
 
-static tf_expr *parse_atom(parser_state *p) {
+static tf_expr *parse_atom(parser_state *p, unsigned depth) {
+    if (expr_depth_exceeded(p, depth)) return NULL;
     skip_ws(p);
     if (p->pos >= p->len) return NULL;
 
     /* Parenthesized expression */
     if (p->src[p->pos] == '(') {
         p->pos++;
-        tf_expr *e = parse_expr(p);
+        tf_expr *e = parse_expr_d(p, depth + 1);
         if (!e) return NULL;
         if (!match_char(p, ')')) { tf_expr_free(e); return NULL; }
         return e;
@@ -201,7 +227,10 @@ static tf_expr *parse_atom(parser_state *p) {
         }
 
         size_t numlen = p->pos - start;
-        char *numstr = malloc(numlen + 1);
+        size_t alloc_len = 0;
+        if (tf_size_add(numlen, 1, &alloc_len) != TF_OK) return NULL;
+        char *numstr = tf_mallocarray_checked(alloc_len, sizeof(char));
+        if (!numstr) return NULL;
         memcpy(numstr, p->src + start, numlen);
         numstr[numlen] = '\0';
 
@@ -234,7 +263,9 @@ static tf_expr *parse_atom(parser_state *p) {
             return NULL;
         }
 
-        char *name = malloc(id_len + 1);
+        size_t name_len = 0;
+        if (tf_size_add(id_len, 1, &name_len) != TF_OK) return NULL;
+        char *name = tf_mallocarray_checked(name_len, sizeof(char));
         if (!name) return NULL;
         memcpy(name, p->src + start, id_len);
         name[id_len] = '\0';
@@ -262,10 +293,13 @@ static tf_expr *parse_atom(parser_state *p) {
                            (isalnum((unsigned char)p->src[p->pos]) || p->src[p->pos] == '_'))
                         p->pos++;
                     if (p->pos == cstart) return NULL;
-                    col_name = malloc(p->pos - cstart + 1);
+                    size_t col_len = p->pos - cstart;
+                    size_t col_alloc_len = 0;
+                    if (tf_size_add(col_len, 1, &col_alloc_len) != TF_OK) return NULL;
+                    col_name = tf_mallocarray_checked(col_alloc_len, sizeof(char));
                     if (!col_name) return NULL;
-                    memcpy(col_name, p->src + cstart, p->pos - cstart);
-                    col_name[p->pos - cstart] = '\0';
+                    memcpy(col_name, p->src + cstart, col_len);
+                    col_name[col_len] = '\0';
                 }
 
                 if (!match_char(p, ')')) { free(col_name); return NULL; }
@@ -277,7 +311,7 @@ static tf_expr *parse_atom(parser_state *p) {
 
             /* General function call: name(arg1, arg2, ...) */
             int n_args = 0;
-            tf_expr **args = parse_arg_list(p, &n_args);
+            tf_expr **args = parse_arg_list(p, &n_args, depth + 1);
             if (!args) { free(name); return NULL; }
 
             tf_expr *e = make_expr(EXPR_FUNC_CALL);
@@ -293,6 +327,14 @@ static tf_expr *parse_atom(parser_state *p) {
             return e;
         }
 
+        if (strcmp(name, "true") == 0 || strcmp(name, "false") == 0) {
+            tf_expr *e = make_expr(EXPR_LIT_BOOL);
+            if (!e) { free(name); return NULL; }
+            e->lit_bool = (strcmp(name, "true") == 0);
+            free(name);
+            return e;
+        }
+
         /* Bare identifier — treat as column reference */
         tf_expr *e = make_expr(EXPR_COL_REF);
         if (!e) { free(name); return NULL; }
@@ -304,12 +346,13 @@ static tf_expr *parse_atom(parser_state *p) {
 }
 
 /* Unary minus: -expr */
-static tf_expr *parse_unary(parser_state *p) {
+static tf_expr *parse_unary(parser_state *p, unsigned depth) {
+    if (expr_depth_exceeded(p, depth)) return NULL;
     skip_ws(p);
     if (p->pos < p->len && p->src[p->pos] == '-') {
         /* Check it's not a comparison op like != */
         p->pos++;
-        tf_expr *child = parse_unary(p);
+        tf_expr *child = parse_unary(p, depth + 1);
         if (!child) return NULL;
         /* Optimize: fold literal negation */
         if (child->kind == EXPR_LIT_INT) {
@@ -325,12 +368,12 @@ static tf_expr *parse_unary(parser_state *p) {
         e->child = child;
         return e;
     }
-    return parse_atom(p);
+    return parse_atom(p, depth);
 }
 
 /* Multiplicative: unary (('*' | '/') unary)* */
-static tf_expr *parse_mul(parser_state *p) {
-    tf_expr *left = parse_unary(p);
+static tf_expr *parse_mul(parser_state *p, unsigned depth) {
+    tf_expr *left = parse_unary(p, depth);
     if (!left) return NULL;
 
     for (;;) {
@@ -340,7 +383,7 @@ static tf_expr *parse_mul(parser_state *p) {
         if (op_char != '*' && op_char != '/') break;
         p->pos++;
 
-        tf_expr *right = parse_unary(p);
+        tf_expr *right = parse_unary(p, depth);
         if (!right) { tf_expr_free(left); return NULL; }
 
         expr_kind kind = (op_char == '*') ? EXPR_MUL : EXPR_DIV;
@@ -354,8 +397,8 @@ static tf_expr *parse_mul(parser_state *p) {
 }
 
 /* Additive: mul_expr (('+' | '-') mul_expr)* */
-static tf_expr *parse_add(parser_state *p) {
-    tf_expr *left = parse_mul(p);
+static tf_expr *parse_add(parser_state *p, unsigned depth) {
+    tf_expr *left = parse_mul(p, depth);
     if (!left) return NULL;
 
     for (;;) {
@@ -368,7 +411,7 @@ static tf_expr *parse_add(parser_state *p) {
          * Since we're at the add level, '+' and '-' are always arithmetic. */
         p->pos++;
 
-        tf_expr *right = parse_mul(p);
+        tf_expr *right = parse_mul(p, depth);
         if (!right) { tf_expr_free(left); return NULL; }
 
         expr_kind kind = (op_char == '+') ? EXPR_ADD : EXPR_SUB;
@@ -381,14 +424,14 @@ static tf_expr *parse_add(parser_state *p) {
     return left;
 }
 
-static tf_expr *parse_cmp(parser_state *p) {
-    tf_expr *left = parse_add(p);
+static tf_expr *parse_cmp(parser_state *p, unsigned depth) {
+    tf_expr *left = parse_add(p, depth);
     if (!left) return NULL;
 
     cmp_op op;
     if (peek_cmp_op(p, &op)) {
         consume_cmp_op(p, op);
-        tf_expr *right = parse_add(p);
+        tf_expr *right = parse_add(p, depth);
         if (!right) { tf_expr_free(left); return NULL; }
 
         tf_expr *e = make_expr(EXPR_CMP);
@@ -402,23 +445,24 @@ static tf_expr *parse_cmp(parser_state *p) {
     return left;
 }
 
-static tf_expr *parse_not(parser_state *p) {
+static tf_expr *parse_not(parser_state *p, unsigned depth) {
+    if (expr_depth_exceeded(p, depth)) return NULL;
     if (match_keyword(p, "not")) {
-        tf_expr *child = parse_not(p);
+        tf_expr *child = parse_not(p, depth + 1);
         if (!child) return NULL;
         tf_expr *e = make_expr(EXPR_NOT);
         if (!e) { tf_expr_free(child); return NULL; }
         e->child = child;
         return e;
     }
-    return parse_cmp(p);
+    return parse_cmp(p, depth);
 }
 
-static tf_expr *parse_and(parser_state *p) {
-    tf_expr *left = parse_not(p);
+static tf_expr *parse_and(parser_state *p, unsigned depth) {
+    tf_expr *left = parse_not(p, depth);
     if (!left) return NULL;
     while (match_keyword(p, "and")) {
-        tf_expr *right = parse_not(p);
+        tf_expr *right = parse_not(p, depth);
         if (!right) { tf_expr_free(left); return NULL; }
         tf_expr *e = make_expr(EXPR_AND);
         if (!e) { tf_expr_free(left); tf_expr_free(right); return NULL; }
@@ -429,11 +473,11 @@ static tf_expr *parse_and(parser_state *p) {
     return left;
 }
 
-static tf_expr *parse_or(parser_state *p) {
-    tf_expr *left = parse_and(p);
+static tf_expr *parse_or(parser_state *p, unsigned depth) {
+    tf_expr *left = parse_and(p, depth);
     if (!left) return NULL;
     while (match_keyword(p, "or")) {
-        tf_expr *right = parse_and(p);
+        tf_expr *right = parse_and(p, depth);
         if (!right) { tf_expr_free(left); return NULL; }
         tf_expr *e = make_expr(EXPR_OR);
         if (!e) { tf_expr_free(left); tf_expr_free(right); return NULL; }
@@ -444,18 +488,28 @@ static tf_expr *parse_or(parser_state *p) {
     return left;
 }
 
-static tf_expr *parse_expr(parser_state *p) {
-    return parse_or(p);
+static tf_expr *parse_expr_d(parser_state *p, unsigned depth) {
+    if (expr_depth_exceeded(p, depth)) return NULL;
+    return parse_or(p, depth);
 }
 
 tf_expr *tf_expr_parse(const char *text) {
-    if (!text) return NULL;
-    parser_state p = { .src = text, .pos = 0, .len = strlen(text) };
-    tf_expr *e = parse_expr(&p);
-    if (!e) return NULL;
+    if (!text || !*text) {
+        tf_set_last_error("expression: empty expression");
+        return NULL;
+    }
+    parser_state p = { .src = text, .pos = 0, .len = strlen(text), .depth_error = 0 };
+    tf_expr *e = parse_expr_d(&p, 0);
+    if (!e) {
+        tf_set_last_error(p.depth_error ? "expression: nesting too deep" : "expression: invalid syntax");
+        return NULL;
+    }
     /* Ensure we consumed all input */
     skip_ws(&p);
     if (p.pos < p.len) {
+        char buf[128];
+        snprintf(buf, sizeof(buf), "expression: unexpected input near byte %zu", p.pos);
+        tf_set_last_error(buf);
         tf_expr_free(e);
         return NULL;
     }
@@ -511,8 +565,8 @@ typedef struct {
  * Uses a ring buffer approach: each call gets a slot, wrapping around. */
 #define SCRATCH_SLOTS 8
 #define SCRATCH_SLOT_SIZE 4096
-static char scratch_buf[SCRATCH_SLOTS][SCRATCH_SLOT_SIZE];
-static int scratch_idx = 0;
+static _Thread_local char scratch_buf[SCRATCH_SLOTS][SCRATCH_SLOT_SIZE];
+static _Thread_local size_t scratch_idx = 0;
 
 static char *scratch_alloc(void) {
     char *slot = scratch_buf[scratch_idx % SCRATCH_SLOTS];
@@ -530,6 +584,146 @@ static eval_val val_bool(int v) { return (eval_val){ .tag = VAL_BOOL, .b = v };
 static eval_val val_date(int32_t v) { return (eval_val){ .tag = VAL_DATE, .date = v }; }
 static eval_val val_timestamp(int64_t v) { return (eval_val){ .tag = VAL_TIMESTAMP, .ts = v }; }
 
+typedef enum {
+    TF_EXPR_TRUNC_YEAR,
+    TF_EXPR_TRUNC_MONTH,
+    TF_EXPR_TRUNC_DAY,
+    TF_EXPR_TRUNC_HOUR,
+    TF_EXPR_TRUNC_MINUTE,
+    TF_EXPR_TRUNC_SECOND,
+} tf_expr_trunc_level;
+
+static int expr_parse_trunc_level(const char *s, tf_expr_trunc_level *level) {
+    if (!s || !level) return 0;
+    if (strcmp(s, "year") == 0 || strcmp(s, "years") == 0) {
+        *level = TF_EXPR_TRUNC_YEAR; return 1;
+    }
+    if (strcmp(s, "month") == 0 || strcmp(s, "months") == 0) {
+        *level = TF_EXPR_TRUNC_MONTH; return 1;
+    }
+    if (strcmp(s, "day") == 0 || strcmp(s, "days") == 0) {
+        *level = TF_EXPR_TRUNC_DAY; return 1;
+    }
+    if (strcmp(s, "hour") == 0 || strcmp(s, "hours") == 0) {
+        *level = TF_EXPR_TRUNC_HOUR; return 1;
+    }
+    if (strcmp(s, "minute") == 0 || strcmp(s, "minutes") == 0) {
+        *level = TF_EXPR_TRUNC_MINUTE; return 1;
+    }
+    if (strcmp(s, "second") == 0 || strcmp(s, "seconds") == 0) {
+        *level = TF_EXPR_TRUNC_SECOND; return 1;
+    }
+    return 0;
+}
+
+static int parse_temporal_string(const char *s, int *y, int *mo, int *d,
+                                 int *h, int *mi, int *se, int *frac_us,
+                                 int *has_time) {
+    if (!s) return 0;
+    *y = *mo = *d = *h = *mi = *se = *frac_us = 0;
+    *has_time = 0;
+
+    int n = sscanf(s, "%d-%d-%dT%d:%d:%d", y, mo, d, h, mi, se);
+    if (n >= 6) {
+        *has_time = 1;
+        const char *dot = strchr(s, '.');
+        if (dot) {
+            int frac = 0, digits = 0;
+            dot++;
+            while (digits < 6 && dot[digits] >= '0' && dot[digits] <= '9') {
+                frac = frac * 10 + (dot[digits] - '0');
+                digits++;
+            }
+            while (digits > 0 && digits < 6) { frac *= 10; digits++; }
+            *frac_us = frac;
+        }
+        return 1;
+    }
+    n = sscanf(s, "%d-%d-%d %d:%d:%d", y, mo, d, h, mi, se);
+    if (n >= 6) {
+        *has_time = 1;
+        const char *dot = strchr(s, '.');
+        if (dot) {
+            int frac = 0, digits = 0;
+            dot++;
+            while (digits < 6 && dot[digits] >= '0' && dot[digits] <= '9') {
+                frac = frac * 10 + (dot[digits] - '0');
+                digits++;
+            }
+            while (digits > 0 && digits < 6) { frac *= 10; digits++; }
+            *frac_us = frac;
+        }
+        return 1;
+    }
+    n = sscanf(s, "%d-%d-%d", y, mo, d);
+    return n >= 3;
+}
+
+static int eval_temporal_parts(eval_val v, int *y, int *mo, int *d,
+                               int *h, int *mi, int *se, int *frac_us,
+                               int32_t *date_days, int64_t *timestamp_us,
+                               int *is_timestamp, int *is_string) {
+    *y = *mo = *d = *h = *mi = *se = *frac_us = 0;
+    *date_days = 0;
+    *timestamp_us = 0;
+    *is_timestamp = 0;
+    *is_string = 0;
+
+    if (v.tag == VAL_DATE) {
+        tf_date_to_ymd(v.date, y, mo, d);
+        *date_days = v.date;
+        return 1;
+    }
+    if (v.tag == VAL_TIMESTAMP) {
+        tf_timestamp_to_parts(v.ts, y, mo, d, h, mi, se, frac_us);
+        *date_days = tf_date_from_ymd(*y, *mo, *d);
+        *timestamp_us = v.ts;
+        *is_timestamp = 1;
+        return 1;
+    }
+    if (v.tag == VAL_STR) {
+        int has_time = 0;
+        if (!parse_temporal_string(v.s, y, mo, d, h, mi, se, frac_us, &has_time)) return 0;
+        *date_days = tf_date_from_ymd(*y, *mo, *d);
+        if (has_time) {
+            *timestamp_us = tf_timestamp_from_parts(*y, *mo, *d, *h, *mi, *se, *frac_us);
+            *is_timestamp = 1;
+        }
+        *is_string = 1;
+        return 1;
+    }
+    return 0;
+}
+
+static int32_t expr_trunc_date(int32_t days, tf_expr_trunc_level level) {
+    int y, mo, d;
+    tf_date_to_ymd(days, &y, &mo, &d);
+    switch (level) {
+        case TF_EXPR_TRUNC_YEAR:  return tf_date_from_ymd(y, 1, 1);
+        case TF_EXPR_TRUNC_MONTH: return tf_date_from_ymd(y, mo, 1);
+        default:                  return days;
+    }
+}
+
+static int64_t expr_trunc_timestamp(int64_t us, tf_expr_trunc_level level) {
+    int y, mo, d, h, mi, se, frac;
+    tf_timestamp_to_parts(us, &y, &mo, &d, &h, &mi, &se, &frac);
+    switch (level) {
+        case TF_EXPR_TRUNC_YEAR:   return tf_timestamp_from_parts(y, 1, 1, 0, 0, 0, 0);
+        case TF_EXPR_TRUNC_MONTH:  return tf_timestamp_from_parts(y, mo, 1, 0, 0, 0, 0);
+        case TF_EXPR_TRUNC_DAY:    return tf_timestamp_from_parts(y, mo, d, 0, 0, 0, 0);
+        case TF_EXPR_TRUNC_HOUR:   return tf_timestamp_from_parts(y, mo, d, h, 0, 0, 0);
+        case TF_EXPR_TRUNC_MINUTE: return tf_timestamp_from_parts(y, mo, d, h, mi, 0, 0);
+        case TF_EXPR_TRUNC_SECOND: return tf_timestamp_from_parts(y, mo, d, h, mi, se, 0);
+    }
+    return us;
+}
+
+static int64_t timestamp_epoch_seconds(int64_t us) {
+    if (us >= 0) return us / 1000000LL;
+    return -(((-us) + 999999LL) / 1000000LL);
+}
+
 /* Convert to double for numeric comparison */
 static double to_double(eval_val v) {
     if (v.tag == VAL_INT) return (double)v.i;
@@ -541,6 +735,13 @@ static int is_numeric(eval_val v) {
     return v.tag == VAL_INT || v.tag == VAL_FLOAT;
 }
 
+static int eval_truthy(eval_val v) {
+    if (v.tag == VAL_BOOL) return v.b;
+    if (v.tag == VAL_INT) return v.i != 0;
+    if (v.tag == VAL_FLOAT) return v.f != 0.0;
+    return v.tag != VAL_NULL;
+}
+
 static eval_val eval_cmp(eval_val lv, eval_val rv, cmp_op op) {
     /* Null comparisons: null != anything is true, null == null is true */
     if (lv.tag == VAL_NULL || rv.tag == VAL_NULL) {
@@ -565,6 +766,20 @@ static eval_val eval_cmp(eval_val lv, eval_val rv, cmp_op op) {
         }
     }
 
+    /* Boolean comparison */
+    if (lv.tag == VAL_BOOL && rv.tag == VAL_BOOL) {
+        int l = lv.b ? 1 : 0;
+        int r = rv.b ? 1 : 0;
+        switch (op) {
+            case CMP_GT: return val_bool(l > r);
+            case CMP_GE: return val_bool(l >= r);
+            case CMP_LT: return val_bool(l < r);
+            case CMP_LE: return val_bool(l <= r);
+            case CMP_EQ: return val_bool(l == r);
+            case CMP_NE: return val_bool(l != r);
+        }
+    }
+
     /* Numeric comparison */
     if (is_numeric(lv) && is_numeric(rv)) {
         double l = to_double(lv);
@@ -688,7 +903,9 @@ static const char *val_to_str(eval_val v, char *buf, size_t buf_sz) {
     switch (v.tag) {
         case VAL_STR:  return v.s;
         case VAL_INT:  snprintf(buf, buf_sz, "%lld", (long long)v.i); return buf;
-        case VAL_FLOAT: snprintf(buf, buf_sz, "%g", v.f); return buf;
+        case VAL_FLOAT:
+            if (tf_format_float64(buf, buf_sz, v.f) != TF_OK && buf_sz > 0) buf[0] = '\0';
+            return buf;
         case VAL_BOOL: return v.b ? "true" : "false";
         case VAL_DATE: tf_date_format(v.date, buf, buf_sz); return buf;
         case VAL_TIMESTAMP: tf_timestamp_format(v.ts, buf, buf_sz); return buf;
@@ -870,13 +1087,43 @@ static eval_val eval_func(const char *name, eval_val *args, int n_args) {
 
     /* if(cond, then, else) */
     if (strcmp(name, "if") == 0 && n_args == 3) {
-        if (args[0].tag == VAL_BOOL)
-            return args[0].b ? args[1] : args[2];
-        /* Truthy: non-null, non-zero */
-        int truthy = (args[0].tag != VAL_NULL);
-        if (args[0].tag == VAL_INT) truthy = (args[0].i != 0);
-        if (args[0].tag == VAL_FLOAT) truthy = (args[0].f != 0.0);
-        return truthy ? args[1] : args[2];
+        return eval_truthy(args[0]) ? args[1] : args[2];
+    }
+
+    /* case_when(cond, value, ..., default) — first matching condition */
+    if (strcmp(name, "case_when") == 0 && n_args >= 2) {
+        int pair_count = n_args / 2;
+        int default_idx = (n_args % 2 == 1) ? n_args - 1 : -1;
+        for (int i = 0; i < pair_count; i++) {
+            if (eval_truthy(args[i * 2])) return args[i * 2 + 1];
+        }
+        return default_idx >= 0 ? args[default_idx] : val_null();
+    }
+
+    /* case_match(value, key, result, ..., default) — first equal key */
+    if (strcmp(name, "case_match") == 0 && n_args >= 3) {
+        int remaining = n_args - 1;
+        int pair_count = remaining / 2;
+        int default_idx = (remaining % 2 == 1) ? n_args - 1 : -1;
+        for (int i = 0; i < pair_count; i++) {
+            eval_val eq = eval_cmp(args[0], args[1 + i * 2], CMP_EQ);
+            if (eq.tag == VAL_BOOL && eq.b) return args[2 + i * 2];
+        }
+        return default_idx >= 0 ? args[default_idx] : val_null();
+    }
+
+    /* if_any(pred, ...) / if_all(pred, ...) — row-local boolean reduction */
+    if (strcmp(name, "if_any") == 0) {
+        for (int i = 0; i < n_args; i++) {
+            if (eval_truthy(args[i])) return val_bool(1);
+        }
+        return val_bool(0);
+    }
+    if (strcmp(name, "if_all") == 0) {
+        for (int i = 0; i < n_args; i++) {
+            if (!eval_truthy(args[i])) return val_bool(0);
+        }
+        return val_bool(1);
     }
 
     /* coalesce(a, b, ...) — first non-null */
@@ -887,6 +1134,65 @@ static eval_val eval_func(const char *name, eval_val *args, int n_args) {
         return val_null();
     }
 
+    /* between(x, lower, upper) / inrange(x, lower, upper) — inclusive range predicate */
+    if ((strcmp(name, "between") == 0 || strcmp(name, "inrange") == 0) && n_args == 3) {
+        if (args[0].tag == VAL_NULL || args[1].tag == VAL_NULL || args[2].tag == VAL_NULL)
+            return val_null();
+        eval_val ge = eval_cmp(args[0], args[1], CMP_GE);
+        eval_val le = eval_cmp(args[0], args[2], CMP_LE);
+        if (ge.tag != VAL_BOOL || le.tag != VAL_BOOL) return val_null();
+        return val_bool(ge.b && le.b);
+    }
+
+    /* ---- Date/time functions ---- */
+
+    if ((strcmp(name, "year") == 0 || strcmp(name, "month") == 0 ||
+         strcmp(name, "day") == 0 || strcmp(name, "hour") == 0 ||
+         strcmp(name, "minute") == 0 || strcmp(name, "second") == 0 ||
+         strcmp(name, "weekday") == 0 || strcmp(name, "epoch") == 0) && n_args == 1) {
+        if (args[0].tag == VAL_NULL) return val_null();
+        int y, mo, d, h, mi, se, frac, is_ts, is_str;
+        int32_t days;
+        int64_t us;
+        if (!eval_temporal_parts(args[0], &y, &mo, &d, &h, &mi, &se, &frac,
+                                 &days, &us, &is_ts, &is_str)) return val_null();
+        (void)frac; (void)is_str;
+        if (strcmp(name, "year") == 0) return val_int(y);
+        if (strcmp(name, "month") == 0) return val_int(mo);
+        if (strcmp(name, "day") == 0) return val_int(d);
+        if (strcmp(name, "hour") == 0) return val_int(h);
+        if (strcmp(name, "minute") == 0) return val_int(mi);
+        if (strcmp(name, "second") == 0) return val_int(se);
+        if (strcmp(name, "weekday") == 0) return val_int(tf_date_weekday(days));
+        if (strcmp(name, "epoch") == 0) {
+            if (is_ts) return val_int(timestamp_epoch_seconds(us));
+            return val_int((int64_t)days * 86400LL);
+        }
+    }
+
+    if (strcmp(name, "date_trunc") == 0 && n_args == 2) {
+        if (args[0].tag == VAL_NULL || args[1].tag != VAL_STR) return val_null();
+        tf_expr_trunc_level level;
+        if (!expr_parse_trunc_level(args[1].s, &level)) return val_null();
+        int y, mo, d, h, mi, se, frac, is_ts, is_str;
+        int32_t days;
+        int64_t us;
+        if (!eval_temporal_parts(args[0], &y, &mo, &d, &h, &mi, &se, &frac,
+                                 &days, &us, &is_ts, &is_str)) return val_null();
+        (void)y; (void)mo; (void)d; (void)h; (void)mi; (void)se; (void)frac;
+        if (args[0].tag == VAL_DATE) return val_date(expr_trunc_date(days, level));
+        if (args[0].tag == VAL_TIMESTAMP) return val_timestamp(expr_trunc_timestamp(us, level));
+        if (is_str) {
+            char *out = scratch_alloc();
+            if (is_ts) {
+                tf_timestamp_format(expr_trunc_timestamp(us, level), out, SCRATCH_SLOT_SIZE);
+            } else {
+                tf_date_format(expr_trunc_date(days, level), out, SCRATCH_SLOT_SIZE);
+            }
+            return val_str(out);
+        }
+    }
+
     /* ---- Math functions ---- */
 
     /* abs(x) */
@@ -1137,6 +1443,8 @@ static eval_val eval_node(const tf_expr *e, const tf_batch *batch, size_t row) {
             return val_float(e->lit_float);
         case EXPR_LIT_STR:
             return val_str(e->lit_str);
+        case EXPR_LIT_BOOL:
+            return val_bool(e->lit_bool);
         case EXPR_COL_REF: {
             int ci = tf_batch_col_index(batch, e->col_name);
             if (ci < 0) return val_null();

package/csrc/expr.h

@@ -11,6 +11,7 @@ typedef enum {
   EXPR_LIT_INT,
   EXPR_LIT_FLOAT,
   EXPR_LIT_STR,
+  EXPR_LIT_BOOL,
   EXPR_COL_REF,
   EXPR_CMP,
   EXPR_AND,
@@ -34,6 +35,7 @@ struct tf_expr {
     int64_t lit_int;
     double  lit_float;
     char   *lit_str;
+    int     lit_bool;
     char   *col_name;    /* for EXPR_COL_REF */
     struct {              /* for EXPR_CMP */
       struct tf_expr *left;