*** ./msql/msql_priv.h~	Tue Oct 17 01:06:55 1995
--- ./msql/msql_priv.h	Thu Oct 26 00:39:00 1995
***************
*** 64,70 ****
  		double	realVal;
  		ident_t	*identVal;
  	} val;
! 	int	type,
  		nullVal,
  		dataLen;
  } val_t;
--- 64,73 ----
  		double	realVal;
  		ident_t	*identVal;
  	} val;
! 	char	table[NAME_LEN],
! 		name[NAME_LEN];
! 	int	op,offs,ftype,
! 		type,
  		nullVal,
  		dataLen;
  } val_t;
***************
*** 91,97 ****
  	struct	field_ps *next;
  } field_t;
  
- 
  /* 
  ** Where clause list element 
  */
--- 94,99 ----
***************
*** 246,251 ****
--- 248,258 ----
  #define GE_OP		6
  #define LIKE_OP		7
  #define NOT_LIKE_OP	8
+ 
+ #define PLU_OP		9
+ #define MIN_OP		10
+ #define MUL_OP		11
+ #define DIV_OP		12
  
  #define	NO_BOOL		0
  #define	AND_BOOL	1
*** ./msql/msqldb.c~	Wed Oct 18 03:43:33 1995
--- ./msql/msqldb.c	Thu Oct 26 13:59:44 1995
***************
*** 2220,2225 ****
--- 2220,2229 ----
  		{
  			(void)strcpy(curField->table,table);
  		}
+ 		if (curField->value && *(curField->value->name) && !*(curField->value->table))
+ 		{
+ 			(void)strcpy(curField->value->table,table);
+ 		}
  		curField=curField->next;
  	}
  	msqlTrace(TRACE_OUT,"qualifyField()");
***************
*** 2514,2519 ****
--- 2518,2597 ----
  	msqlTrace(TRACE_OUT,"setupFields()");
  	return(0);
  }
+ /****************************************************************************
+ ** 	_setupVal
+ **
+ **	Purpose	: Determine the byte offset into a row of the desired values
+ **	Args	: Empty field list (field location) array,
+ **		  List of desired fields
+ **	Returns	: -1 on error
+ **	Notes	: The field list array holds the byte offsets for the
+ **		  fields.  ie. array element 0 will hold the byte offset
+ **		  of the first desired field etc.
+ */
+ 
+ static int setupVal(cacheEntry, fields)
+ 	cache_t	*cacheEntry;
+ 	field_t	*fields;
+ {
+ 	REG 	field_t	*curField,
+ 			*fieldDef;
+ 	int	curOffset;
+ 
+ 	msqlTrace(TRACE_IN,"setupVal()");
+ 
+ 	curField = fields;
+ 	
+ 	while(curField)
+ 	{
+ 	    if (curField->value && *(curField->value->name))
+ 	    {
+ 		    fieldDef = cacheEntry->def;
+ 		    curOffset = 0;
+ 		    while(fieldDef)
+ 		    {
+ 			if(strcmp(curField->value->name,fieldDef->name) == 0 &&
+ 			   strcmp(curField->value->table,fieldDef->table) == 0)
+ 			{
+ 				curField->value->ftype= fieldDef->type;
+ 				curField->value->offs = curOffset;
+ 				if (curField->type != curField->value->ftype)
+ 				{
+ 					sprintf(errMsg, TYPE_ERROR, curField->name);
+ 					msqlDebug(MOD_ERR,TYPE_ERROR, curField->name);
+ 					return(-1);
+ 				}
+ 				break;
+ 			}
+ 			curOffset += fieldDef->length+1; /* +1 for null indicator */
+ 			fieldDef = fieldDef->next;
+ 		    }
+ 		    if(!fieldDef)  /* Bad entry */
+ 		    {
+ 			if (curField->value->table)
+ 			{
+ 			    sprintf(errMsg,"Unknown field \"%s.%s\"",
+ 					curField->value->table,curField->value->name);
+ 			    msqlDebug(MOD_ERR,"Unknown field \"%s.%s\"\n",
+ 					curField->value->table,curField->value->name);
+ 			    msqlTrace(TRACE_OUT,"setupVal()");
+ 			    return(-1);
+ 			}
+ 			else
+ 			{
+ 			    sprintf(errMsg,"Unknown field \"%s\"",curField->value->name);
+ 			    msqlDebug(MOD_ERR,"Unknown field \"%s\"\n",curField->value->name);
+ 			    msqlTrace(TRACE_OUT,"setupVal()");
+ 			    return(-1);
+ 			}
+ 		    }
+ 	    }
+ 	    
+ 	    curField = curField->next;
+ 	}
+ 	msqlTrace(TRACE_OUT,"setupVal()");
+ 	return(0);
+ }
  
  
  
***************
*** 2873,2878 ****
--- 2951,2957 ----
  **	Notes	: 
  */
  
+ 
  static void updateValues(row,fields,flist)
  	char	*row;
  	field_t	*fields;
***************
*** 2881,2918 ****
  	int	*offset;
  	field_t	*curField;
  	char	*cp;
  
  	msqlTrace(TRACE_IN,"updateValues()");
  	curField = fields;
  	offset = flist;
  	while(curField)
  	{
- 		cp = row + *offset;
  		if (!curField->value->nullVal)
                  {
                          *cp = '\001';
                          cp++;
  			switch(curField->type)
  			{
  				case INT_TYPE:
  #ifndef _CRAY
! 					bcopy4(&(curField->value->val.intVal),
! 						cp);
  #else
! 				 	packInt32(curField->value->val.intVal, 
! 						cp);
  #endif
  					break;
  		
  				case CHAR_TYPE:
  					(void)bzero(cp, curField->length);
! 					strncpy(cp, curField->value->val.charVal,
! 						curField->length);
  					break;
  
  				case REAL_TYPE:
! 					bcopy8(&(curField->value->val.realVal),
! 						cp);
  					break;
  			}
  		}
--- 2960,3054 ----
  	int	*offset;
  	field_t	*curField;
  	char	*cp;
+ 	int	iVal,iFVal;
+ 	double	dVal,dFVal;
+ 	char	*cVal;
  
  	msqlTrace(TRACE_IN,"updateValues()");
  	curField = fields;
  	offset = flist;
  	while(curField)
  	{
  		if (!curField->value->nullVal)
                  {
+ 			switch(curField->type)
+ 			{
+ 				case INT_TYPE:
+ 				 	iVal = curField->value->val.intVal;
+ 					break;
+ 		
+ 				case CHAR_TYPE:
+ 					cVal = curField->value->val.charVal;
+ 					break;
+ 
+ 				case REAL_TYPE:
+ 					dVal = curField->value->val.realVal;
+ 					break;
+ 			}
+ 			if (curField->value->op && curField->value->offs)
+ 			{
+                             cp = row + curField->value->offs +1;
+                             if (curField->type == INT_TYPE)
+ 			    {
+ 			    	memcpy(&iFVal,cp,sizeof(int));
+                             	switch(curField->value->op)
+                             	{
+                             	    case PLU_OP:
+                             	    	iVal += iFVal ;
+                             	    	break;
+                             	    case MIN_OP:
+                             	    	iVal = iFVal -iVal;
+                             	    	break;
+                             	    case MUL_OP:
+                             	    	iVal = iFVal *iVal;
+                             	    	break;
+                             	    case DIV_OP:
+                             	    	if (iVal)
+                             	    		iVal = iFVal /iVal;
+                             	    	break;
+                             	}
+                             }
+                             if (curField->type == REAL_TYPE)
+                             {	
+ 			    	memcpy(&dFVal,cp,sizeof(int));
+                             	switch(curField->value->op)
+                             	{
+                             	    case PLU_OP:
+                             	    	dVal += dFVal ;
+                             	    	break;
+                             	    case MIN_OP:
+                             	    	dVal = dFVal -dVal;
+                             	    	break;
+                             	    case MUL_OP:
+                             	    	dVal = dFVal +dVal;
+                             	    	break;
+                             	    case DIV_OP:
+                             	    	if (dVal != 0.0)
+                             	    		dVal = dFVal / dVal;
+                             	    	break;
+                             	}
+                             }
+                         }
+                         cp = row + *offset;
                          *cp = '\001';
                          cp++;
  			switch(curField->type)
  			{
  				case INT_TYPE:
  #ifndef _CRAY
!  					bcopy(&iVal,cp, sizeof(int));
  #else
!  				 	packInt32(iVal, cp);
  #endif
  					break;
  		
  				case CHAR_TYPE:
  					(void)bzero(cp, curField->length);
!  					strncpy(cp, cVal, curField->length);
  					break;
  
  				case REAL_TYPE:
!  					bcopy(&dVal,cp, sizeof(double));
  					break;
  			}
  		}
***************
*** 2930,2936 ****
  
  
  
- 
  /****************************************************************************
  ** 	_translateValues
  **
--- 3066,3071 ----
***************
*** 4214,4219 ****
--- 4349,4364 ----
  
  	if (key)
  	{
+ 			/* check for autokey generation */
+ 		if (key->type == INT_TYPE && key->value->nullVal) {
+ 		   int freeKey = cacheEntry->numRows;
+ 		   key->value->nullVal = 0;
+ 		   key->value->type = INT_TYPE;
+ 		   do {
+ 			freeKey++;
+ 			key->value->val.intVal = freeKey;
+ 		   } while (readKey(cacheEntry,key) != NO_POS);
+ 		}
  		if (readKey(cacheEntry,key) != NO_POS)
  		{
  			sprintf(errMsg,KEY_UNIQ_ERROR, key->name);
***************
*** 4296,4301 ****
--- 4441,4451 ----
  		msqlTrace(TRACE_OUT,"msqlUpdate()");
  		return(-1);
  	}
+ 	if (setupVal(cacheEntry,fields) < 0)
+ 	{
+ 		msqlTrace(TRACE_OUT,"msqlUpdate()");
+ 		return(-1);
+ 	}
  	(void)bzero(clist,MAX_FIELDS * sizeof(int));
  	if (setupConds(cacheEntry,clist,conds,&keyCond) < 0)
  	{
***************
*** 5195,5201 ****
  
  	numRows = (entry->size / (entry->rowLen+1));
  	qSortRowBuf = (char *)malloc(entry->rowLen);
! 	bSort(entry, order, olist, 0, numRows-1);
  	free(qSortRowBuf);
  
  	msqlTrace(TRACE_OUT,"createSortedTable()");
--- 5345,5351 ----
  
  	numRows = (entry->size / (entry->rowLen+1));
  	qSortRowBuf = (char *)malloc(entry->rowLen);
! 	bSort(entry, order, olist, 0, numRows > 0 ? numRows-1 : 0);
  	free(qSortRowBuf);
  
  	msqlTrace(TRACE_OUT,"createSortedTable()");
*** ./msql/msql_yacc.y~	Mon Oct  2 23:11:27 1995
--- ./msql/msql_yacc.y	Thu Oct 26 00:44:11 1995
***************
*** 93,98 ****
--- 93,103 ----
  %token	CHAR
  %token	REAL
  
+ %token  OPPLU
+ %token  OPMIN
+ %token  OPMUL
+ %token  OPDIV
+ 
  %token  LIMIT
  
  %%
***************
*** 220,226 ****
  item_list
  	: item_list ',' field
  	| field
! 	| '*'
  		{
  			ident_t	*tmp;
  
--- 225,231 ----
  item_list
  	: item_list ',' field
  	| field
! 	| OPMUL
  		{
  			ident_t	*tmp;
  
***************
*** 383,393 ****
  values
  	: values ','  literal
  		{ 
! 			msqlAddFieldValue($3);
  		 }
  	|  literal
  		{ 
! 			msqlAddFieldValue($1); 
  		}
  
  
--- 388,398 ----
  values
  	: values ','  literal
  		{ 
! 			msqlAddFieldValue($3,0,0);
  		 }
  	|  literal
  		{ 
! 			msqlAddFieldValue($1,0,0); 
  		}
  
  
***************
*** 405,417 ****
  		}
  
  update_list
! 	: update_list ',' qual_ident EQ literal
! 		{ msqlAddField($3,0,0,0,0);
! 		  msqlAddFieldValue($5); }
! 	| qual_ident EQ literal
  		{ msqlAddField($1,0,0,0,0);
! 		  msqlAddFieldValue($3); }
  
  
  /*
  ** Delete : conditionally delete table entries (or all entries)
--- 410,431 ----
  		}
  
  update_list
! 	: update_list ',' update_set
! 	| update_set
! 
! update_set : qual_ident EQ literal
  		{ msqlAddField($1,0,0,0,0);
! 		  msqlAddFieldValue($3,0,0); 
! 		  }
! 	| qual_ident EQ qual_ident numop literal
! 		{ msqlAddField($1,0,0,0,0);
! 		  msqlAddFieldValue($5,$3,$4);
! 		  }
  
+ numop : OPPLU { $$ = (char *)PLU_OP; }
+ 	| OPMIN { $$ = (char *)MIN_OP; }
+ 	| OPMUL { $$ = (char *)MUL_OP; }
+ 	| OPDIV { $$ = (char *)DIV_OP; }
  
  /*
  ** Delete : conditionally delete table entries (or all entries)
***************
*** 445,450 ****
--- 459,494 ----
  		{
  			$$ = (char *)msqlCreateValue($1,REAL_TYPE,0);
  			(void)myFree($1);
+ 		}
+ 	| OPPLU NUM
+ 		{
+ 			$$ = (char *)msqlCreateValue($2,INT_TYPE,0);
+ 			(void)myFree($2);
+ 		}
+ 	| OPPLU REAL_NUM
+ 		{
+ 			$$ = (char *)msqlCreateValue($2,REAL_TYPE,0);
+ 			(void)myFree($2);
+ 		}
+ 	| OPMIN NUM
+ 		{	char *p;
+ 
+ 			p=(char*)malloc(strlen($2)+2);
+ 			*p='-'; strcpy(p+1,$2);
+ 			$$ = (char *)msqlCreateValue(p,INT_TYPE,0);
+ 			(void)myFree($2);
+ 
+ 			free(p);
+ 		}
+ 	| OPMIN REAL_NUM
+ 		{	char *p;
+ 
+ 			p=(char*)malloc(strlen($2)+2);
+ 			*p='-'; strcpy(p+1,$2);
+ 			$$ = (char *)msqlCreateValue(p,REAL_TYPE,0);
+ 			(void)myFree($2);
+ 
+ 			free(p);
  		}
  	| NULLSYM
  		{
*** ./msql/msql_proc.c~	Tue Oct  3 00:34:51 1995
--- ./msql/msql_proc.c	Thu Oct 26 00:43:04 1995
***************
*** 246,251 ****
--- 246,253 ----
  
  	msqlTrace(TRACE_IN,"msqlCreateValue()");
  	new = (val_t *)malloc(sizeof(val_t));
+ 	*(new->table) = *(new->name) = 0;
+ 	new->offs=0;
  	new->type = type;
  	new->dataLen = tokLen;
  	switch(type)
***************
*** 392,405 ****
  
  	msqlTrace(TRACE_IN,"msqlAddField()");
  
! 	if (*(ident->seg2))
  	{
  		name = ident->seg2;
  		table = ident->seg1;
  	}
  	else
  	{
! 		name = ident->seg1;
  		table = NULL;
  	}
  
--- 394,407 ----
  
  	msqlTrace(TRACE_IN,"msqlAddField()");
  
! 	if (*(ident->seg1))
  	{
  		name = ident->seg2;
  		table = ident->seg1;
  	}
  	else
  	{
! 		name = ident->seg2;
  		table = NULL;
  	}
  
***************
*** 500,507 ****
  }
  
  
! msqlAddFieldValue(value)
  	val_t	*value;
  {
  	register field_t	*fieldVal;
  	u_char	*buf;
--- 502,511 ----
  }
  
  
! msqlAddFieldValue(value,ident,operator)
  	val_t	*value;
+ 	ident_t *ident;
+ 	int operator;
  {
  	register field_t	*fieldVal;
  	u_char	*buf;
***************
*** 516,521 ****
--- 520,541 ----
  		fieldVal = lastField->next;
  		lastField = lastField->next;
  	}
+ 	if (ident && operator)
+ 	{
+ 		value->op=operator;
+ 
+ 		if (*(ident->seg1))
+ 		{
+ 			(void)strncpy(value->table,ident->seg1,NAME_LEN - 1);
+ 			(void)strncpy(value->name ,ident->seg2,NAME_LEN - 1);
+ 		}
+ 		else
+ 		{
+ 			(void)memset(value->table,0,NAME_LEN);
+ 			(void)strncpy(value->name ,ident->seg2,NAME_LEN - 1);
+ 		}
+ 		free(ident);
+ 	}
  	if (fieldVal)
  	{
  		if (fieldVal->type == CHAR_TYPE)
***************
*** 555,568 ****
  
  	msqlTrace(TRACE_IN,"msqlAddCond()");
  
! 	if (*(ident->seg2))
  	{
  		name = ident->seg2;
  		table = ident->seg1;
  	}
  	else
  	{
! 		name = ident->seg1;
  		table = NULL;
  	}
  
--- 575,588 ----
  
  	msqlTrace(TRACE_IN,"msqlAddCond()");
  
! 	if (*(ident->seg1))
  	{
  		name = ident->seg2;
  		table = ident->seg1;
  	}
  	else
  	{
! 		name = ident->seg2;
  		table = NULL;
  	}
  
*** ./msql/msql_lex.c~	Tue Oct  3 00:34:51 1995
--- ./msql/msql_lex.c	Thu Oct 26 00:39:06 1995
***************
*** 296,301 ****
--- 296,303 ----
  }
  
  
+ u_char readTextLiteralDelimiter;
+ 
  u_char *readTextLiteral(tok)
  	u_char	*tok;
  {
***************
*** 318,324 ****
  				break;
  	
  			case '\'':
! 				bail=1;
  				break;
  		}
  	}
--- 320,328 ----
  				break;
  	
  			case '\'':
! 			case '"':
! 				if (readTextLiteralDelimiter == c)
! 					bail=1;
  				break;
  		}
  	}
***************
*** 365,372 ****
  						yylineno++;
  					c = yySkip();
  				}
! 				if (c == '\'')
  				{
  					state = 12;
  					break;
  				}
--- 369,377 ----
  						yylineno++;
  					c = yySkip();
  				}
! 				if ((c == '\'') || (c == '"'))
  				{
+ 					readTextLiteralDelimiter=c;
  					state = 12;
  					break;
  				}
***************
*** 392,402 ****
  					else
  						yyUnget();
  				}
! 				if (c == '-' || c == '+')
! 				{
! 					state = 9;
! 					break;
! 				}
  				if (iscompop(c))
  				{
  					state = 10;
--- 397,411 ----
  					else
  						yyUnget();
  				}
! 				if ((c == '+') || (c == '-')
! 				 || (c == '*') || (c == '/')) {
! 					yytext = tokenDup(tokStart,yytoklen);
! 					yylval = (YYSTYPE) yytext;
! 					if (c == '+') yyReturn(OPPLU);
! 					if (c == '-') yyReturn(OPMIN);
! 					if (c == '*') yyReturn(OPMUL);
! 					if (c == '/') yyReturn(OPDIV);
! 					}
  				if (iscompop(c))
  				{
  					state = 10;
***************
*** 563,569 ****
  				}
  				state = 999;
  				break;
- 
  	
  			/* State 12: Incomplete text string */
  			CASE(12)
--- 572,577 ----
***************
*** 577,589 ****
  				state = 999;
  				break;
  
- 
- 
  			/* State 13: Complete text string */
  			CASE(13)
  				yyReturn(token(TEXT));
  				break;
- 
  
  			/* State 14: Comment */
  			CASE(14)
--- 585,594 ----