UnQL

**   drh@hwaci.com
**   http://www.hwaci.com/drh/
**
*************************************************************************
*/
#include "xjd1Int.h"





struct Function {
  int nArg;

  const char *zName;

  JsonNode *(*xFunc)(int nArg, JsonNode **apArg);
  int (*xStep)(int nArg, JsonNode **apArg, void **);
  JsonNode *(*xFinal)(void *);
};














































/*






































































































































































** Implementation of scalar function "length(x)".
*/
static JsonNode *xLength(int nArg, JsonNode **apArg){
  JsonNode *pRet;
  JsonNode *pStr;
  int nRet;
  assert( nArg==1 );

  pStr = apArg[0];
  if( pStr->eJType==XJD1_STRING ){
    nRet = xjd1Strlen30(pStr->u.z);
  }else{
    String str;

    xjd1StringInit(&str, 0, 0);
    xjd1JsonToString(pStr, &str);
    nRet = str.nUsed;
    xjd1StringClear(&str);
  }

  pRet = xjd1JsonNew(0);
  pRet->eJType = XJD1_REAL;
  pRet->u.r = (double)nRet;

  return pRet;
}

static int xCountStep(int nArg, JsonNode **apArg, void **pp){

  int nCount = (int)*pp;
  nCount++;
  *pp = (void *)nCount;
  return XJD1_OK;
}

static JsonNode *xCountFinal(void *p){
  JsonNode *pRet;
  pRet = xjd1JsonNew(0);
  pRet->eJType = XJD1_REAL;
  pRet->u.r = (double)(int)p;
  return pRet;
}



int xjd1AggregateInit(xjd1_stmt *pStmt, Query *pQuery, Expr *p){
  Aggregate *pAgg;
 
  assert( pQuery->eQType==TK_SELECT );
  pAgg = pQuery->u.simple.pAgg;
  if( pAgg==0 ){
................................................................................
*/
int xjd1FunctionInit(Expr *p, xjd1_stmt *pStmt, Query *pQuery, int eExpr){
  char *zName;
  int nArg;
  int nByte;
  int i;
  int bAggOk;


  static Function aFunc[] = {
    {  1, "length", xLength, 0, 0 },

    { -1, "count", 0, xCountStep, xCountFinal },





  };

  assert( p->eType==TK_FUNCTION && p->eClass==XJD1_EXPR_FUNC );
  assert( pQuery || eExpr==0 );

  /* Set bAggOk to true if aggregate functions may be used in this context. */
  bAggOk = (pQuery && pQuery->eQType==TK_SELECT
................................................................................

  zName = p->u.func.zFName;
  nArg = p->u.func.args->nEItem;

  for(i=0; i<ArraySize(aFunc); i++){
    Function *pFunc = &aFunc[i];
    assert( (pFunc->xFunc==0)==(pFunc->xStep && pFunc->xFinal) );
    if( !strcmp(pFunc->zName, zName) && (nArg==pFunc->nArg || 0>pFunc->nArg) ){

      if( pFunc->xStep ){
        int rc;
        if( bAggOk==0 ){
          const char *zErrMsg = "illegal use of aggregate function: %s";
          xjd1StmtError(pStmt, XJD1_ERROR, zErrMsg, zName);
          return XJD1_ERROR;
        }

        /* Add this aggregate function to the Query.pAgg->apExpr[] array. */
        rc = xjd1AggregateInit(pStmt, pQuery, p);
        if( rc!=XJD1_OK ) return rc;
      }
      p->u.func.pFunction = pFunc;



      break;
    }
  }

  if( !p->u.func.pFunction ){




    xjd1StmtError(pStmt, XJD1_ERROR, "no such function: %s", zName);

    return XJD1_ERROR;
  }

  nByte = sizeof(JsonNode *) * nArg;
  p->u.func.apArg = (JsonNode **)xjd1PoolMallocZero(&pStmt->sPool, nByte);
  if( !p->u.func.apArg ){
    return XJD1_NOMEM;

**   drh@hwaci.com
**   http://www.hwaci.com/drh/
**
*************************************************************************
*/
#include "xjd1Int.h"

/*
** A structure used to store the definition of a query language function 
** or aggregate.
*/
struct Function {
  int nMinArg;
  int nMaxArg;
  const char *zName;

  JsonNode *(*xFunc)(int nArg, JsonNode **apArg);
  int (*xStep)(int nArg, JsonNode **apArg, void **);
  JsonNode *(*xFinal)(void *);
};

/*************************************************************************
** Start of implementation of aggregate functions:
**
**   count()
**     This aggregate may be invoked with zero or one argument. If no
**     arguments are specified, it returns the number of rows visited. If
**     one argument is supplied, it returns the number of rows visited
**     for which the argument was anything other than a NULL. In all cases,
**     this function returns a non-negative integer value.
**
**   min()
**     This aggregate is invoked with exactly one argument. If no rows are 
**     visited, NULL is returned. Otherwise, it returns a copy of the 
**     smallest argument it is passed. The comparisons used to determine
**     which argument is the smallest are performed using the same rules
**     as for the < and > operators.
**
**   max()
**     This aggregate is invoked with exactly one argument. If no rows are 
**     visited, NULL is returned. Otherwise, it returns a copy of the 
**     largest argument it is passed. The comparisons used to determine
**     which argument is the largest are performed using the same rules
**     as for the < and > operators.
**
**   array()
**     This aggregate is invoked with exactly one argument. If no rows are 
**     visited, an empty array is returned. Otherwise, an array containing
**     the argument passed to this aggregate for each row visited is returned.
**     The order in which the values appear in the returned array is not
**     defined.
**
**   sum()
**     This aggregate is invoked with exactly one argument. If no rows are 
**     visited, the value 0.0 (a number) is returned. Otherwise, each argument
**     is converted to a number and the sum of all converted arguments 
**     returned. Any value that cannot be converted to a number (i.e. a struct,
**     an array or any string value that does not look like a number) is 
**     treated as 0.0.
**
**   avg()
**     This aggregate is invoked with exactly one argument. If no rows are
**     visited, NULL is returned. Otherwise, the expression avg(X) is 
**     equivalent to (sum(X)/count()).
*/

/*
** Aggregate function count().
*/
static int xCountStep(int nArg, JsonNode **apArg, void **pp){
  int *pnCount = (int *)*pp;
  if( pnCount==0 ){
    pnCount = xjd1MallocZero(sizeof(int));
    *pp = (void *)pnCount;
  }
  if( nArg==0 || apArg[0]->eJType!=XJD1_NULL ){
    (*pnCount)++;
  }
  return XJD1_OK;
}
static JsonNode *xCountFinal(void *p){
  JsonNode *pRet;
  pRet = xjd1JsonNew(0);
  pRet->eJType = XJD1_REAL;
  if( p ){
    pRet->u.r = (double)*(int *)p;
    xjd1_free(p);
  }
  return pRet;
}

/*
** Aggregate functions min() and max().
*/
static int xMinStep(int nArg, JsonNode **apArg, void **pp){
  JsonNode *pArg;
  JsonNode *pBest = *pp;
  assert( nArg==1 );
  pArg = apArg[0];
  if( !pBest || xjd1JsonCompare(pArg, pBest)<0 ){
    xjd1JsonFree(pBest);
    *pp = (void *)xjd1JsonRef(pArg);
  }
  return XJD1_OK;
}
static int xMaxStep(int nArg, JsonNode **apArg, void **pp){
  JsonNode *pArg;
  JsonNode *pBest = *pp;
  assert( nArg==1 );
  pArg = apArg[0];
  if( !pBest || xjd1JsonCompare(pArg, pBest)>0 ){
    xjd1JsonFree(pBest);
    *pp = (void *)xjd1JsonRef(pArg);
  }
  return XJD1_OK;
}
static JsonNode *xMinMaxFinal(void *p){
  JsonNode *pRet;
  if( p ){
    pRet = (JsonNode *)p;
  }else{
    pRet = xjd1JsonNew(0);
    pRet->eJType = XJD1_NULL;
  }
  return pRet;
}

/*
** Aggregate function array().
*/
static int xArrayStep(int nArg, JsonNode **apArg, void **pp){
  JsonNode *pArray = (JsonNode *)*pp;
  JsonNode *pArg = apArg[0];
  int nNew;
  if( !pArray ){
    pArray = xjd1JsonNew(0);
    pArray->eJType = XJD1_ARRAY;
    *pp = (void *)pArray;
  }
  nNew = pArray->u.ar.nElem+1;
  pArray->u.ar.apElem = (JsonNode **)xjd1_realloc(
      pArray->u.ar.apElem, nNew*sizeof(JsonNode *)
  );
  pArray->u.ar.nElem = nNew;
  pArray->u.ar.apElem[nNew-1] = xjd1JsonRef(pArg);
  return XJD1_OK;
}
static JsonNode *xArrayFinal(void *p){
  JsonNode *pArray = (JsonNode *)p;
  if( !pArray ){
    pArray = xjd1JsonNew(0);
    pArray->eJType = XJD1_ARRAY;
  }
  return pArray;
}

/*
** Aggregate function sum()
*/
static int xSumStep(int nArg, JsonNode **apArg, void **pp){
  JsonNode *pVal = (JsonNode *)*pp;
  double rVal = 0.0;
  if( !pVal ){
    pVal = xjd1JsonNew(0);
    pVal->eJType = XJD1_REAL;
    *pp = (void *)pVal;
  }
  if( XJD1_OK==xjd1JsonToReal(apArg[0], &rVal) ){
    pVal->u.r += rVal;
  }
  return XJD1_OK;
}
static JsonNode *xSumFinal(void *p){
  JsonNode *pVal = (JsonNode *)p;
  if( !pVal ){
    pVal = xjd1JsonNew(0);
    pVal->eJType = XJD1_REAL;
  }
  return pVal;
}

/*
** Aggregate function avg()
*/
typedef struct AvgCtx AvgCtx;
struct AvgCtx {
  int nRow;
  double rSum;
};
static int xAvgStep(int nArg, JsonNode **apArg, void **pp){
  AvgCtx *pCtx = (AvgCtx *)*pp;
  double rVal = 0.0;
  if( !pCtx ){
    pCtx = xjd1MallocZero(sizeof(AvgCtx));
    *pp = (void *)pCtx;
  }
  pCtx->nRow++;
  if( XJD1_OK==xjd1JsonToReal(apArg[0], &rVal) ){
    pCtx->rSum += rVal;
  }
  return XJD1_OK;
}
static JsonNode *xAvgFinal(void *p){
  AvgCtx *pCtx = (AvgCtx *)p;
  JsonNode *pRet;

  pRet = xjd1JsonNew(0);
  if( pCtx ){
    pRet->eJType = XJD1_REAL;
    pRet->u.r = pCtx->rSum/(double)pCtx->nRow;
    xjd1_free(pCtx);
  }else{
    pRet->eJType = XJD1_NULL;
  }

  return pRet;
}

/*
** End of implementation of aggregates.
*************************************************************************/

/*************************************************************************
** Start of implementation of scalar functions:
**
**   length()
**     This function is called with exactly one argument. It converts
**     that argument to a string, and returns the number of characters
**     in that string.
**
*/

/*
** Scalar function "length(x)".
*/
static JsonNode *xLength(int nArg, JsonNode **apArg){
  JsonNode *pRet;
  JsonNode *pStr;
  int nRet;
  assert( nArg==1 );

  pStr = apArg[0];
  if( pStr->eJType==XJD1_STRING ){
    nRet = xjd1Strlen30(pStr->u.z);
  }else{
    String str;

    xjd1StringInit(&str, 0, 0);
    xjd1JsonToString(pStr, &str);
    nRet = str.nUsed;
    xjd1StringClear(&str);
  }

  pRet = xjd1JsonNew(0);
  pRet->eJType = XJD1_REAL;
  pRet->u.r = (double)nRet;

  return pRet;
}


/*
** End of implementation of scalar functions.













*************************************************************************/

int xjd1AggregateInit(xjd1_stmt *pStmt, Query *pQuery, Expr *p){
  Aggregate *pAgg;
 
  assert( pQuery->eQType==TK_SELECT );
  pAgg = pQuery->u.simple.pAgg;
  if( pAgg==0 ){
................................................................................
*/
int xjd1FunctionInit(Expr *p, xjd1_stmt *pStmt, Query *pQuery, int eExpr){
  char *zName;
  int nArg;
  int nByte;
  int i;
  int bAggOk;
  int bWrongNumArgs = 0;

  static Function aFunc[] = {
    {  1,1, "length", xLength, 0, 0 },

    {  0,1, "count", 0, xCountStep, xCountFinal  },
    {  1,1, "min",   0, xMinStep,   xMinMaxFinal },
    {  1,1, "max",   0, xMaxStep,   xMinMaxFinal },
    {  1,1, "array", 0, xArrayStep, xArrayFinal  },
    {  1,1, "sum",   0, xSumStep,   xSumFinal    },
    {  1,1, "avg",   0, xAvgStep,   xAvgFinal    },
  };

  assert( p->eType==TK_FUNCTION && p->eClass==XJD1_EXPR_FUNC );
  assert( pQuery || eExpr==0 );

  /* Set bAggOk to true if aggregate functions may be used in this context. */
  bAggOk = (pQuery && pQuery->eQType==TK_SELECT
................................................................................

  zName = p->u.func.zFName;
  nArg = p->u.func.args->nEItem;

  for(i=0; i<ArraySize(aFunc); i++){
    Function *pFunc = &aFunc[i];
    assert( (pFunc->xFunc==0)==(pFunc->xStep && pFunc->xFinal) );
    if( !strcmp(pFunc->zName, zName) ){
      if( nArg<=pFunc->nMaxArg && nArg>=pFunc->nMinArg ){
        if( pFunc->xStep ){
          int rc;
          if( bAggOk==0 ){
            const char *zErrMsg = "illegal use of aggregate function: %s";
            xjd1StmtError(pStmt, XJD1_ERROR, zErrMsg, zName);
            return XJD1_ERROR;
          }

          /* Add this aggregate function to the Query.pAgg->apExpr[] array. */
          rc = xjd1AggregateInit(pStmt, pQuery, p);
          if( rc!=XJD1_OK ) return rc;
        }
        p->u.func.pFunction = pFunc;
      }else{
        bWrongNumArgs = 1;
      }
      break;
    }
  }

  if( !p->u.func.pFunction ){
    if( bWrongNumArgs ){
      xjd1StmtError(pStmt, XJD1_ERROR, 
          "wrong number of arguments to function %s()", zName);
    }else{
      xjd1StmtError(pStmt, XJD1_ERROR, "no such function: %s", zName);
    }
    return XJD1_ERROR;
  }

  nByte = sizeof(JsonNode *) * nArg;
  p->u.func.apArg = (JsonNode **)xjd1PoolMallocZero(&pStmt->sPool, nByte);
  if( !p->u.func.apArg ){
    return XJD1_NOMEM;

  /* Generate an Expr object that is a function call. */
  static Expr *funcExpr(Parse *p, Token *pFName, ExprList *pArgs){
    Expr *pNew = xjd1PoolMallocZero(p->pPool, sizeof(*pNew));
    if( pNew ){
      pNew->eType = TK_FUNCTION; 
      pNew->eClass = XJD1_EXPR_FUNC;
      pNew->u.func.zFName = tokenStr(p, pFName);



      pNew->u.func.args = pArgs;
    }
    return pNew;
  }

  /* Generate an Expr object that is a subquery. */
  static Expr *subqExpr(Parse *p, Query *pQuery){

  /* Generate an Expr object that is a function call. */
  static Expr *funcExpr(Parse *p, Token *pFName, ExprList *pArgs){
    Expr *pNew = xjd1PoolMallocZero(p->pPool, sizeof(*pNew));
    if( pNew ){
      pNew->eType = TK_FUNCTION; 
      pNew->eClass = XJD1_EXPR_FUNC;
      pNew->u.func.zFName = tokenStr(p, pFName);
      if( pArgs==0 ){
        pArgs = xjd1PoolMallocZero(p->pPool, sizeof(ExprList));
      }
      pNew->u.func.args = pArgs;
    }
    return pNew;
  }

  /* Generate an Expr object that is a subquery. */
  static Expr *subqExpr(Parse *p, Query *pQuery){

.read base02.test
.read base03.test
.read base04.test
.read base05.test
.read base06.test
.read base07.test
.read base08.test

.read base02.test
.read base03.test
.read base04.test
.read base05.test
.read base06.test
.read base07.test
.read base08.test
.read base09.test

-- Test the aggregate functions - avg()
--

.new t1.db

CREATE COLLECTION c1;
INSERT INTO c1 VALUE {a:1, b:6,  c:4, d:"abc"};
INSERT INTO c1 VALUE {a:2, b:4,  c:3, d:null };
INSERT INTO c1 VALUE {a:3, b:2,  c:2, d:0.0  };
INSERT INTO c1 VALUE {a:4, b:8,  c:1         };
INSERT INTO c1 VALUE {a:5, b:10, c:5, d:-1.0 };
INSERT INTO c1 VALUE {a:6, b:10, c:5, d:null };


.testcase 1
SELECT count()  FROM c1 WHERE c1.a == -1;
SELECT count()  FROM c1 WHERE c1.a == 1;
SELECT count(c1.d) FROM c1 WHERE c1.a<5;
.json 0 1 2

.testcase 2
SELECT min(c1.a) FROM c1 WHERE c1.a==-1;
SELECT min(c1.a) FROM c1 WHERE c1.a<5;
SELECT min(c1.c) FROM c1 WHERE c1.a<5;
SELECT min(c1.b) FROM c1 WHERE c1.a<5;
SELECT min(c1.d) FROM c1 WHERE c1.a<5;
SELECT min(c1.d) FROM c1 WHERE c1.a<6;
SELECT min(c1.d) FROM c1 WHERE c1.a<3;
.result null 1 1 2 0 -1 null

.testcase 3
SELECT max(c1.a) FROM c1 WHERE c1.a==-1;
SELECT max(c1.a) FROM c1 WHERE c1.a<5;
SELECT max(c1.c) FROM c1 WHERE c1.a<5;
SELECT max(c1.b) FROM c1 WHERE c1.a<5;
SELECT max(c1.d) FROM c1 WHERE c1.a<5;
SELECT max(c1.d) FROM c1 WHERE c1.a<6;
SELECT max(c1.d) FROM c1 WHERE c1.a<3;
SELECT max(c1.d) FROM c1 WHERE c1.a>4;
.result null 4 4 8 "abc" "abc" "abc" null

.testcase 4
SELECT array(c1.a) FROM c1 WHERE c1.a==-1;
SELECT array(c1.a) FROM c1 WHERE c1.a<7;
.json [] [1,2,3,4,5,6]

.testcase 5
SELECT sum(c1.a) FROM c1 WHERE c1.a==-1;
SELECT sum(c1.a) FROM c1 WHERE c1.a<7;
SELECT sum(c1.d) FROM c1 WHERE c1.a<7 && c1.a>4;
.json 0 21 -1

.testcase 6
SELECT avg(c1.a) FROM c1 WHERE c1.a==-1;
SELECT avg(c1.a) FROM c1 WHERE c1.a<7;
SELECT avg(c1.d) FROM c1 WHERE c1.a<7 && c1.a>1;
.json null 3.5 -0.2


.testcase 7
SELECT count(c1.a,c1.b) FROM c1;
.error ERROR wrong number of arguments to function count()
.testcase 8
SELECT array() FROM c1;
.error ERROR wrong number of arguments to function array()
.testcase 9
SELECT array(c1.a,c1.b) FROM c1;
.error ERROR wrong number of arguments to function array()
.testcase 10
SELECT max() FROM c1;
.error ERROR wrong number of arguments to function max()
.testcase 11
SELECT max(c1.a,c1.b) FROM c1;
.error ERROR wrong number of arguments to function max()