PhpRedis Table

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

입력

redis.c: PHP_METHOD(Redis, sqlselect)

/* 2021.03.04(Thu) */
/* "select" "select columns from string.key where ... " */
/* {{{ proto array Redis::sqlselect(string sql_category, string sql_statement) */
PHP_METHOD(Redis, sqlselect)
{
    REDIS_PROCESS_KW_CMD("SELECT", redis_sqlselect_cmd, redis_table_reply);
}
/* }}} */

redis_commands.c: redis_sqlselect_cmd()

/* 2021.03.04(Thu) */
/* "select", "select columns from string.key where ... */
int redis_sqlselect_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
    char *kw, char **cmd, int *cmd_len, short *slot, void **ctx)
{
    zval *z_args;
    smart_string cmdstr = {0};
    size_t i;
    int argc = ZEND_NUM_ARGS();
    
    if (argc != 1) {
        return FAILURE;
    }
    /* Initialize our command */
    redis_cmd_init_sstr(&cmdstr, argc, kw, strlen(kw));

    z_args = emalloc(argc * sizeof(zval));
    if (z_args == NULL) {
        php_error_docref(NULL, E_WARNING, "------------> emalloc() error");
        return FAILURE;
    }
    if (zend_get_parameters_array(ht, argc, z_args) == FAILURE) {
        efree(z_args);
        php_error_docref(NULL, E_WARNING, "------------> zend_get_parameters_array() error");
        return FAILURE;
    }

    redis_cmd_append_sstr(&cmdstr, Z_STRVAL(z_args[0]),Z_STRLEN(z_args[0]));

    efree(z_args);

    *cmd     = cmdstr.c;
    *cmd_len = cmdstr.len;

    /* 
     * *2
     * $6
     * SELECT
     * $23
     * select * from string.*;
     * "*2rn$6rnSELECTrn$23rnselect * from string.*;rn" -> include every line \r\n -> 46 chars
     */

    return SUCCESS;
}

library.c: redis_sock_read_table()

/* 2021.02.24(Wed) 
 * redis_sock_read_table() for table, rows, columns
 * Copy and Add switch case: table, rows, columns
 */
PHP_REDIS_API char *
redis_sock_read_table(RedisSock *redis_sock, int *buf_len)
{
    char inbuf[4096];
    size_t len; 
    
    *buf_len = 0; 
    if (redis_sock_gets(redis_sock, inbuf, sizeof(inbuf) - 1, &len) < 0) { 
        return NULL;
    }    

    switch(inbuf[0]) {
        case '#': /* Redis Table -> #rows\r\n */
          *buf_len = atoi(inbuf + 1);
          return "#"; 
        case '^': /* Redis Rows -> ^columns\r\n */
          *buf_len = atoi(inbuf + 1);
          return "^"; 
        case '!': /* Redis Columns -> !5\r\nvalue\r\n */
          *buf_len = atoi(inbuf + 1);
          if (redis_sock_gets(redis_sock, inbuf, sizeof(inbuf) - 1, &len) < 0) { 
              return NULL;
          }    
          return estrndup(inbuf, *buf_len);

        case '-': /* Redis Error */
            redis_sock_set_err(redis_sock, inbuf+1, len);
            /* Filter our ERROR through the few that should actually throw */
            redis_error_throw(redis_sock);
            return NULL;
        case '$': /* Redis Bulk */
            *buf_len = atoi(inbuf + 1);
            return redis_sock_read_bulk_reply(redis_sock, *buf_len);
        case '*': /* Redis Array(multibulk) */
            /* For null multi-bulk replies (like timeouts from brpoplpush): */
            if(memcmp(inbuf + 1, "-1", 2) == 0) { 
                return NULL;
            }    
            /* fall through */
        case '+': /* Redis Status */
        case ':': /* Redis Integer */
            /* Single Line Reply */
            /* +OK or :123 */
            if (len > 1) {
                *buf_len = len;
                return estrndup(inbuf, *buf_len);
            }
        default:
            zend_throw_exception_ex(redis_exception_ce, 0,
                "2) protocol error, got '%c' as reply type byte\n",
                inbuf[0]);
    }

    return NULL;
}

library.c: redis_table_reply()

/* 2021.02.24(Wed) */
PHP_REDIS_API int
redis_table_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval *z_tab, void *ctx)
{
    zval z_table, *z_row;
    int rows=0, columns=0;
    char *resp;
    int resp_len;
    char buf[4096];
    int buf_len;
    int len;
    int i,j;

    /* '#' rows */
    if ((resp = redis_sock_read_table(redis_sock, &resp_len)) == NULL) {
        if (IS_ATOMIC(redis_sock)) {
            RETURN_FALSE;
        }
        add_next_index_bool(z_tab, 0);
        return;
    }

    if (strncmp(resp, "#", 1)) { /* not # */
        if (IS_ATOMIC(redis_sock)) {
          RETVAL_FALSE;
        } else {
          add_next_index_bool(z_tab,0);
        }
        return -1;
    }
    rows = resp_len;

    array_init(&z_table);

    for (i=0; i < rows; i++) {
      /* '^' columns */
      if ((resp = redis_sock_read_table(redis_sock, &resp_len)) == NULL) {
          if (IS_ATOMIC(redis_sock)) {
              RETURN_FALSE;
          }
          add_next_index_bool(z_tab, 0);
          return;
      }
      columns = resp_len;
      z_row = emalloc(sizeof(zval));
      array_init(z_row);
      for (j=0; j < columns; j++) {
        if ((resp = redis_sock_read_table(redis_sock, &resp_len)) == NULL) {
          return;
        }
        add_next_index_stringl(z_row, resp, resp_len);
      }
      add_next_index_zval(&z_table, z_row);
      //efree(z_row);
    }

    if (IS_ATOMIC(redis_sock)) {
      RETVAL_ZVAL(&z_table,0,1); /* copy:0, free:1 */
    } else {
      add_next_index_zval(z_tab, &z_table);
    }
    return 0;
}

<< Program	Table	PREDIS >>