InfiniSQL  v0.1.2-alpha
Massive Scale Transaction Processing
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Public Types | Public Member Functions | Public Attributes | List of all members
Statement Class Reference

contains all necessary information to execute a SQL statement More...

#include <Asts.h>

Collaboration diagram for Statement:
Collaboration graph
[legend]

Classes

struct  column_s
 FROM clause column. More...
 
struct  inobject_s
 IN (or NOT IN) row values. More...
 
struct  orderbyitem_s
 ORDER BY fields and order. More...
 
struct  query_s
 all elements for a main or sub-query More...
 
struct  reentry_s
 continuation destination More...
 
struct  results_s
 results of evaulations during query execution, including final results More...
 

Public Types

enum  direction_e { FROM_ABOVE = 1, FROM_LEFT = 2, FROM_RIGHT = 3 }
 Ast walking direction. More...
 

Public Member Functions

 Statement ()
 
 Statement (class TransactionAgent *taPtrarg, class Schema *schemaPtrarg)
 create Statement object More...
 
 Statement (const Statement &orig)
 
Statement & operator= (const Statement &orig)
 
void cp (const Statement &orig)
 deep copy of Statement More...
 
virtual ~Statement ()
 
query_s cpquery (const query_s &orig)
 deep copy of query_s instance More...
 
bool resolveTableFields ()
 resolves table and field names to integers More...
 
bool resolveTableFields2 ()
 
bool resolveFieldNames (class Ast *myPosition)
 
int64_t getfieldid (int64_t tableid, const string &fieldName)
 returns fieldid More...
 
bool stagedPredicate (operatortypes_e op, int64_t tableid, string &leftoperand, string &rightoperand, vector< fieldValue_s > &inValues, const boost::unordered_map< uuRecord_s, stagedRow_s > &stagedRows, boost::unordered_map< uuRecord_s, returnRow_s > &results)
 
void andPredicate (operatortypes_e op, int64_t tableid, string &leftoperand, string &rightoperand, vector< fieldValue_s > &inValues, const boost::unordered_map< uuRecord_s, returnRow_s > &andResults, boost::unordered_map< uuRecord_s, returnRow_s > &results)
 
void execute (class ApiInterface *reentryObject, apifPtr reentryfptr, int64_t reentrypoint, void *reentrydata, class Transaction *transactionPtrarg, const vector< string > &parametersarg)
 execute SQL statement More...
 
void searchExpression (int64_t entrypoint, class Ast *astNode)
 perform search expression More...
 
void branchtotype ()
 SELECT, INSERT, UPDATE, DELETE, stored proc branch to. More...
 
void reenter (int64_t status)
 return to calling function (Statement execution complete) More...
 
void continueSelect (int64_t entrypoint, class Ast *ignorethis)
 continuation for SELECT statement More...
 
void continueDelete (int64_t entrypoint, class Ast *ignorethis)
 continuation for DELETE statement More...
 
void continueInsert (int64_t entrypoint, class Ast *ignorethis)
 continuation for INSERT statement More...
 
void continueUpdate (int64_t entrypoint, class Ast *ignorethis)
 continuation for UPDATE statement More...
 
void startQuery ()
 begin query execution More...
 
void subqueryScalar (class Ast *astnode)
 subquery that returns a scalar More...
 
void subqueryUnique (class Ast *astnode)
 UNIQUE type of subquery. More...
 
void subqueryExists (class Ast *astnode)
 EXISTS subquery. More...
 
void subqueryIn (class Ast *astnode)
 subquery returns list of values for IN predicate More...
 
void abortQuery (int64_t status)
 g-bye More...
 

Public Attributes

class TransactionAgent * taPtr
 
class Schema * schemaPtr
 
reentry_s reentry
 
class Transaction * transactionPtr
 
query_s * currentQuery
 
std::vector< query_s > queries
 
std::vector< std::string > parameters
 
ssize_t queryindex
 

Detailed Description

contains all necessary information to execute a SQL statement

Definition at line 156 of file Asts.h.

Member Enumeration Documentation

enum Statement::direction_e

Ast walking direction.

Enumerator
FROM_ABOVE 
FROM_LEFT 
FROM_RIGHT 

Definition at line 256 of file Asts.h.

257  {
258  FROM_ABOVE = 1,
259  FROM_LEFT = 2,
260  FROM_RIGHT = 3
261  };

Constructor & Destructor Documentation

Statement::Statement ( )

Definition at line 1989 of file Asts.cc.

1990 {
1991 }
Statement::Statement ( class TransactionAgent *  taPtrarg,
class Schema *  schemaPtrarg 
)

create Statement object

Parameters
taPtrargassociated TransactionAgent
schemaPtrargassociated Schema

Definition at line 1993 of file Asts.cc.

References reentry.

1994  :
1995  taPtr(taPtrarg), schemaPtr(schemaPtrarg), transactionPtr(NULL),
1996  currentQuery(NULL)
1997 {
1998  reentry = reentry_s();
1999 }
Statement::Statement ( const Statement &  orig)

Definition at line 2001 of file Asts.cc.

References cp().

2002 {
2003  cp(orig);
2004 }

Here is the call graph for this function:

Statement::~Statement ( )
virtual

Definition at line 2097 of file Asts.cc.

References Statement::inobject_s::expressionlist, Statement::query_s::fieldidAssignments, Statement::query_s::inobject, Statement::query_s::insertColumns, queries, and Statement::query_s::searchCondition.

2098 {
2099  for (size_t n=0; n < queries.size(); n++)
2100  {
2101  query_s &queryRef = queries[n];
2102 
2103  if (queryRef.searchCondition != NULL)
2104  {
2105  delete queryRef.searchCondition;
2106  }
2107 
2108  for (size_t m=0; m < queryRef.inobject.expressionlist.size(); m++)
2109  {
2110  delete queryRef.inobject.expressionlist[m];
2111  }
2112 
2113  boost::unordered_map<int64_t, class Ast *>::iterator it;
2114 
2115  for (it = queryRef.fieldidAssignments.begin();
2116  it != queryRef.fieldidAssignments.end(); it++)
2117  {
2118  delete it->second;
2119  }
2120 
2121  for (size_t m=0; m < queryRef.insertColumns.size(); m++)
2122  {
2123  delete queryRef.insertColumns[m];
2124  }
2125  }
2126 }

Member Function Documentation

void Statement::abortQuery ( int64_t  status)

g-bye

Parameters
statusstatus code returned to caller

Definition at line 5803 of file Asts.cc.

References reenter().

Referenced by Transaction::continueSqlDelete(), Transaction::continueSqlInsert(), Transaction::continueSqlPredicate(), Transaction::continueSqlReplace(), Transaction::continueSqlUpdate(), and continueUpdate().

5804 {
5805  // entire transaction should be rolled back if non-zero status
5806  reenter(status);
5807 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::andPredicate ( operatortypes_e  op,
int64_t  tableid,
string &  leftoperand,
string &  rightoperand,
vector< fieldValue_s > &  inValues,
const boost::unordered_map< uuRecord_s, returnRow_s > &  andResults,
boost::unordered_map< uuRecord_s, returnRow_s > &  results 
)

not yet functional, possibly gratuitous, redundant to stagedPredicate

Definition at line 3472 of file Asts.cc.

References BOOL, fieldInput_u::boolean, CHAR, fieldInput_u::character, CHARX, compareFields(), Table::fields, FLOAT, fieldInput_u::floating, INT, fieldInput_u::integer, fieldValue_s::isnull, like2Regex(), logfile, OPERAND_FIELDID, OPERATOR_BETWEEN, OPERATOR_EQ, OPERATOR_GT, OPERATOR_GTE, OPERATOR_IN, OPERATOR_ISNOTNULL, OPERATOR_ISNULL, OPERATOR_LIKE, OPERATOR_LT, OPERATOR_LTE, OPERATOR_NE, OPERATOR_NOTBETWEEN, OPERATOR_NOTIN, OPERATOR_NOTLIKE, returnRow_s::row, schemaPtr, fieldValue_s::str, Schema::tables, Ast::toFloat(), UINT, fieldInput_u::uinteger, Table::unmakerow(), fieldValue_s::value, and VARCHAR.

Referenced by Ast::evaluate().

3479 {
3480  if (leftoperand[0] != OPERAND_FIELDID)
3481  {
3482  printf("%s %i left operand is not fieldid, it is %c\n", __FILE__,
3483  __LINE__, leftoperand[0]);
3484  return;
3485  }
3486 
3487  int64_t fieldid;
3488  memcpy(&fieldid, &leftoperand[1], sizeof(fieldid));
3489 
3490  class Table &tableRef = *schemaPtr->tables[tableid];
3491  vector<fieldValue_s> fieldValues;
3492 
3493  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
3494 
3495  for (it = andResults.begin(); it != andResults.end(); it++)
3496  {
3497  const uuRecord_s &uurRef = it->first;
3498  const returnRow_s &returnRowRef = it->second;
3499  tableRef.unmakerow((string *)&returnRowRef.row, &fieldValues);
3500  fieldValue_s &lhs = fieldValues[fieldid];
3501 
3502  switch (tableRef.fields[fieldid].type)
3503  {
3504  case INT:
3505  {
3506  switch (op)
3507  {
3508  case OPERATOR_EQ:
3509  {
3510  int64_t rhsval;
3511  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3512 
3513  if (lhs.value.integer==rhsval)
3514  {
3515  results[uurRef] = returnRowRef;
3516  }
3517  }
3518  break;
3519 
3520  case OPERATOR_NE:
3521  {
3522  int64_t rhsval;
3523  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3524 
3525  if (lhs.value.integer!=rhsval)
3526  {
3527  results[uurRef] = returnRowRef;
3528  }
3529  }
3530  break;
3531 
3532  case OPERATOR_GT:
3533  {
3534  int64_t rhsval;
3535  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3536 
3537  if (lhs.value.integer>rhsval)
3538  {
3539  results[uurRef] = returnRowRef;
3540  }
3541  }
3542  break;
3543 
3544  case OPERATOR_LT:
3545  {
3546  int64_t rhsval;
3547  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3548 
3549  if (lhs.value.integer<rhsval)
3550  {
3551  results[uurRef] = returnRowRef;
3552  }
3553  }
3554  break;
3555 
3556  case OPERATOR_GTE:
3557  {
3558  int64_t rhsval;
3559  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3560 
3561  if (lhs.value.integer>=rhsval)
3562  {
3563  results[uurRef] = returnRowRef;
3564  }
3565  }
3566  break;
3567 
3568  case OPERATOR_LTE:
3569  {
3570  int64_t rhsval;
3571  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3572 
3573  if (lhs.value.integer<=rhsval)
3574  {
3575  results[uurRef] = returnRowRef;
3576  }
3577  }
3578  break;
3579 
3580  case OPERATOR_BETWEEN:
3581  {
3582  int64_t rhsval;
3583  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3584  int64_t rhsval2;
3585  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
3586  sizeof(rhsval2));
3587 
3588  if (lhs.value.integer >= rhsval && lhs.value.integer <= rhsval2)
3589  {
3590  results[uurRef] = returnRowRef;
3591  }
3592  }
3593  break;
3594 
3595  case OPERATOR_NOTBETWEEN:
3596  {
3597  int64_t rhsval;
3598  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3599  int64_t rhsval2;
3600  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
3601  sizeof(rhsval2));
3602 
3603  if (lhs.value.integer < rhsval || lhs.value.integer > rhsval2)
3604  {
3605  results[uurRef] = returnRowRef;
3606  }
3607  }
3608  break;
3609 
3610  case OPERATOR_IN:
3611  {
3612  /* do after AST is walkable since inobject contains a
3613  * vector of Ast */
3614  int64_t fieldid;
3615  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3616  vector<fieldValue_s> fieldValues;
3617  class Table &tableRef = *schemaPtr->tables[tableid];
3618  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3619  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
3620 
3621  for (it = andResults.begin(); it != andResults.end(); it++)
3622  {
3623  const uuRecord_s &uurRef = it->first;
3624  const returnRow_s &returnRowRef = it->second;
3625  tableRef.unmakerow((string *)&returnRowRef.row,
3626  &fieldValues);
3627 
3628  for (size_t n=0; inValues.size(); n++)
3629  {
3630  if (compareFields(fieldtype, fieldValues[fieldid],
3631  inValues[n])==true)
3632  {
3633  results[uurRef] = returnRowRef;
3634  }
3635  }
3636  }
3637  }
3638  break;
3639 
3640  case OPERATOR_NOTIN:
3641  {
3642  // do after AST is walkable since inobject contains a vector of Ast *
3643  int64_t fieldid;
3644  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3645  vector<fieldValue_s> fieldValues;
3646  class Table &tableRef = *schemaPtr->tables[tableid];
3647  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3648  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
3649 
3650  for (it = andResults.begin(); it != andResults.end(); it++)
3651  {
3652  const uuRecord_s &uurRef = it->first;
3653  const returnRow_s &returnRowRef = it->second;
3654  tableRef.unmakerow((string *)&returnRowRef.row,
3655  &fieldValues);
3656  bool notin=true;
3657 
3658  for (size_t n=0; inValues.size(); n++)
3659  {
3660  if (compareFields(fieldtype, fieldValues[fieldid],
3661  inValues[n])==true)
3662  {
3663  notin=false;
3664  break;
3665  }
3666  }
3667 
3668  if (notin==true)
3669  {
3670  results[uurRef] = returnRowRef;
3671  }
3672  }
3673  }
3674  break;
3675 
3676  case OPERATOR_ISNULL:
3677  {
3678  if (lhs.isnull==true)
3679  {
3680  results[uurRef] = returnRowRef;
3681  }
3682  }
3683  break;
3684 
3685  case OPERATOR_ISNOTNULL:
3686  {
3687  if (lhs.isnull==false)
3688  {
3689  results[uurRef] = returnRowRef;
3690  }
3691  }
3692  break;
3693 
3694  default:
3695  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
3696  }
3697  }
3698  break;
3699 
3700  case UINT:
3701  {
3702  switch (op)
3703  {
3704  case OPERATOR_EQ:
3705  {
3706  uint64_t rhsval;
3707  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3708 
3709  if (lhs.value.uinteger==rhsval)
3710  {
3711  results[uurRef] = returnRowRef;
3712  }
3713  }
3714  break;
3715 
3716  case OPERATOR_NE:
3717  {
3718  uint64_t rhsval;
3719  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3720 
3721  if (lhs.value.uinteger!=rhsval)
3722  {
3723  results[uurRef] = returnRowRef;
3724  }
3725  }
3726  break;
3727 
3728  case OPERATOR_GT:
3729  {
3730  uint64_t rhsval;
3731  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3732 
3733  if (lhs.value.uinteger>rhsval)
3734  {
3735  results[uurRef] = returnRowRef;
3736  }
3737  }
3738  break;
3739 
3740  case OPERATOR_LT:
3741  {
3742  uint64_t rhsval;
3743  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3744 
3745  if (lhs.value.uinteger<rhsval)
3746  {
3747  results[uurRef] = returnRowRef;
3748  }
3749  }
3750  break;
3751 
3752  case OPERATOR_GTE:
3753  {
3754  uint64_t rhsval;
3755  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3756 
3757  if (lhs.value.uinteger>=rhsval)
3758  {
3759  results[uurRef] = returnRowRef;
3760  }
3761  }
3762  break;
3763 
3764  case OPERATOR_LTE:
3765  {
3766  uint64_t rhsval;
3767  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3768 
3769  if (lhs.value.uinteger<=rhsval)
3770  {
3771  results[uurRef] = returnRowRef;
3772  }
3773  }
3774  break;
3775 
3776  case OPERATOR_BETWEEN:
3777  {
3778  uint64_t rhsval;
3779  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3780  uint64_t rhsval2;
3781  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
3782  sizeof(rhsval2));
3783 
3784  if (lhs.value.uinteger >= rhsval && lhs.value.uinteger <=
3785  rhsval2)
3786  {
3787  results[uurRef] = returnRowRef;
3788  }
3789  }
3790  break;
3791 
3792  case OPERATOR_NOTBETWEEN:
3793  {
3794  uint64_t rhsval;
3795  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3796  uint64_t rhsval2;
3797  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
3798  sizeof(rhsval2));
3799 
3800  if (lhs.value.uinteger < rhsval || lhs.value.uinteger > rhsval2)
3801  {
3802  results[uurRef] = returnRowRef;
3803  }
3804  }
3805  break;
3806 
3807  case OPERATOR_IN:
3808  {
3809  /* do after AST is walkable since inobject contains a vector
3810  * of Ast */
3811  int64_t fieldid;
3812  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3813  vector<fieldValue_s> fieldValues;
3814  class Table &tableRef = *schemaPtr->tables[tableid];
3815  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3816  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
3817 
3818  for (it = andResults.begin(); it != andResults.end(); it++)
3819  {
3820  const uuRecord_s &uurRef = it->first;
3821  const returnRow_s &returnRowRef = it->second;
3822  tableRef.unmakerow((string *)&returnRowRef.row,
3823  &fieldValues);
3824 
3825  for (size_t n=0; inValues.size(); n++)
3826  {
3827  if (compareFields(fieldtype, fieldValues[fieldid],
3828  inValues[n])==true)
3829  {
3830  results[uurRef] = returnRowRef;
3831  }
3832  }
3833  }
3834  }
3835  break;
3836 
3837  case OPERATOR_NOTIN:
3838  {
3839  // do after AST is walkable since inobject contains a vector of Ast *
3840  int64_t fieldid;
3841  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3842  vector<fieldValue_s> fieldValues;
3843  class Table &tableRef = *schemaPtr->tables[tableid];
3844  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3845  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
3846 
3847  for (it = andResults.begin(); it != andResults.end(); it++)
3848  {
3849  const uuRecord_s &uurRef = it->first;
3850  const returnRow_s &returnRowRef = it->second;
3851  tableRef.unmakerow((string *)&returnRowRef.row,
3852  &fieldValues);
3853  bool notin=true;
3854 
3855  for (size_t n=0; inValues.size(); n++)
3856  {
3857  if (compareFields(fieldtype, fieldValues[fieldid],
3858  inValues[n])==true)
3859  {
3860  notin=false;
3861  break;
3862  }
3863  }
3864 
3865  if (notin==true)
3866  {
3867  results[uurRef] = returnRowRef;
3868  }
3869  }
3870  }
3871  break;
3872 
3873  case OPERATOR_ISNULL:
3874  {
3875  if (lhs.isnull==true)
3876  {
3877  results[uurRef] = returnRowRef;
3878  }
3879  }
3880  break;
3881 
3882  case OPERATOR_ISNOTNULL:
3883  {
3884  if (lhs.isnull==false)
3885  {
3886  results[uurRef] = returnRowRef;
3887  }
3888  }
3889  break;
3890 
3891  default:
3892  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
3893  }
3894  }
3895  break;
3896 
3897  case BOOL:
3898  {
3899  switch (op)
3900  {
3901  case OPERATOR_EQ:
3902  {
3903  bool rhsval;
3904  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3905 
3906  if (lhs.value.boolean==rhsval)
3907  {
3908  results[uurRef] = returnRowRef;
3909  }
3910  }
3911  break;
3912 
3913  case OPERATOR_NE:
3914  {
3915  bool rhsval;
3916  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3917 
3918  if (lhs.value.boolean!=rhsval)
3919  {
3920  results[uurRef] = returnRowRef;
3921  }
3922  }
3923  break;
3924 
3925  case OPERATOR_GT:
3926  {
3927  bool rhsval;
3928  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3929 
3930  if (lhs.value.boolean>rhsval)
3931  {
3932  results[uurRef] = returnRowRef;
3933  }
3934  }
3935  break;
3936 
3937  case OPERATOR_LT:
3938  {
3939  bool rhsval;
3940  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3941 
3942  if (lhs.value.boolean<rhsval)
3943  {
3944  results[uurRef] = returnRowRef;
3945  }
3946  }
3947  break;
3948 
3949  case OPERATOR_GTE:
3950  {
3951  bool rhsval;
3952  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3953 
3954  if (lhs.value.boolean>=rhsval)
3955  {
3956  results[uurRef] = returnRowRef;
3957  }
3958  }
3959  break;
3960 
3961  case OPERATOR_LTE:
3962  {
3963  bool rhsval;
3964  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3965 
3966  if (lhs.value.boolean<=rhsval)
3967  {
3968  results[uurRef] = returnRowRef;
3969  }
3970  }
3971  break;
3972 
3973  case OPERATOR_BETWEEN:
3974  {
3975  bool rhsval;
3976  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3977  bool rhsval2;
3978  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
3979  sizeof(rhsval2));
3980 
3981  if (lhs.value.boolean >= rhsval && lhs.value.boolean <= rhsval2)
3982  {
3983  results[uurRef] = returnRowRef;
3984  }
3985  }
3986  break;
3987 
3988  case OPERATOR_NOTBETWEEN:
3989  {
3990  bool rhsval;
3991  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
3992  bool rhsval2;
3993  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
3994  sizeof(rhsval2));
3995 
3996  if (lhs.value.boolean < rhsval || lhs.value.boolean > rhsval2)
3997  {
3998  results[uurRef] = returnRowRef;
3999  }
4000  }
4001  break;
4002 
4003  case OPERATOR_IN:
4004  {
4005  // why do IN on a bool field?
4006  int64_t fieldid;
4007  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4008  vector<fieldValue_s> fieldValues;
4009  class Table &tableRef = *schemaPtr->tables[tableid];
4010  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4011  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4012 
4013  for (it = andResults.begin(); it != andResults.end(); it++)
4014  {
4015  const uuRecord_s &uurRef = it->first;
4016  const returnRow_s &returnRowRef = it->second;
4017  tableRef.unmakerow((string *)&returnRowRef.row,
4018  &fieldValues);
4019 
4020  for (size_t n=0; inValues.size(); n++)
4021  {
4022  if (compareFields(fieldtype, fieldValues[fieldid],
4023  inValues[n])==true)
4024  {
4025  results[uurRef] = returnRowRef;
4026  }
4027  }
4028  }
4029  }
4030  break;
4031 
4032  case OPERATOR_NOTIN:
4033  {
4034  // why do NOT IN on a bool field?
4035  int64_t fieldid;
4036  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4037  vector<fieldValue_s> fieldValues;
4038  class Table &tableRef = *schemaPtr->tables[tableid];
4039  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4040  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4041 
4042  for (it = andResults.begin(); it != andResults.end(); it++)
4043  {
4044  const uuRecord_s &uurRef = it->first;
4045  const returnRow_s &returnRowRef = it->second;
4046  tableRef.unmakerow((string *)&returnRowRef.row,
4047  &fieldValues);
4048  bool notin=true;
4049 
4050  for (size_t n=0; inValues.size(); n++)
4051  {
4052  if (compareFields(fieldtype, fieldValues[fieldid],
4053  inValues[n])==true)
4054  {
4055  notin=false;
4056  break;
4057  }
4058  }
4059 
4060  if (notin==true)
4061  {
4062  results[uurRef] = returnRowRef;
4063  }
4064  }
4065  }
4066  break;
4067 
4068  case OPERATOR_ISNULL:
4069  {
4070  if (lhs.isnull==true)
4071  {
4072  results[uurRef] = returnRowRef;
4073  }
4074  }
4075  break;
4076 
4077  case OPERATOR_ISNOTNULL:
4078  {
4079  if (lhs.isnull==false)
4080  {
4081  results[uurRef] = returnRowRef;
4082  }
4083  }
4084  break;
4085 
4086  default:
4087  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
4088  }
4089  }
4090  break;
4091 
4092  case FLOAT:
4093  {
4094  switch (op)
4095  {
4096  case OPERATOR_EQ:
4097  {
4098  Ast::toFloat(rightoperand, rightoperand);
4099  long double rhsval;
4100  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
4101 
4102  if (lhs.value.floating==rhsval)
4103  {
4104  results[uurRef] = returnRowRef;
4105  }
4106  }
4107  break;
4108 
4109  case OPERATOR_NE:
4110  {
4111  Ast::toFloat(rightoperand, rightoperand);
4112  long double rhsval;
4113  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
4114 
4115  if (lhs.value.floating!=rhsval)
4116  {
4117  results[uurRef] = returnRowRef;
4118  }
4119  }
4120  break;
4121 
4122  case OPERATOR_GT:
4123  {
4124  Ast::toFloat(rightoperand, rightoperand);
4125  long double rhsval;
4126  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
4127 
4128  if (lhs.value.floating>rhsval)
4129  {
4130  results[uurRef] = returnRowRef;
4131  }
4132  }
4133  break;
4134 
4135  case OPERATOR_LT:
4136  {
4137  Ast::toFloat(rightoperand, rightoperand);
4138  long double rhsval;
4139  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
4140 
4141  if (lhs.value.floating<rhsval)
4142  {
4143  results[uurRef] = returnRowRef;
4144  }
4145  }
4146  break;
4147 
4148  case OPERATOR_GTE:
4149  {
4150  Ast::toFloat(rightoperand, rightoperand);
4151  long double rhsval;
4152  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
4153 
4154  if (lhs.value.floating>=rhsval)
4155  {
4156  results[uurRef] = returnRowRef;
4157  }
4158  }
4159  break;
4160 
4161  case OPERATOR_LTE:
4162  {
4163  Ast::toFloat(rightoperand, rightoperand);
4164  long double rhsval;
4165  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
4166 
4167  if (lhs.value.floating<=rhsval)
4168  {
4169  results[uurRef] = returnRowRef;
4170  }
4171  }
4172  break;
4173 
4174  case OPERATOR_BETWEEN:
4175  {
4176  long double rhsval;
4177  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
4178  long double rhsval2;
4179  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
4180  sizeof(rhsval2));
4181 
4182  if (lhs.value.floating >= rhsval && lhs.value.floating <=
4183  rhsval2)
4184  {
4185  results[uurRef] = returnRowRef;
4186  }
4187  }
4188  break;
4189 
4190  case OPERATOR_NOTBETWEEN:
4191  {
4192  long double rhsval;
4193  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
4194  long double rhsval2;
4195  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
4196  sizeof(rhsval2));
4197 
4198  if (lhs.value.floating < rhsval || lhs.value.floating > rhsval2)
4199  {
4200  results[uurRef] = returnRowRef;
4201  }
4202  }
4203  break;
4204 
4205  case OPERATOR_IN:
4206  {
4207  /* do after AST is walkable since inobject contains a vector
4208  * of Ast */
4209  int64_t fieldid;
4210  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4211  vector<fieldValue_s> fieldValues;
4212  class Table &tableRef = *schemaPtr->tables[tableid];
4213  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4214  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4215 
4216  for (it = andResults.begin(); it != andResults.end(); it++)
4217  {
4218  const uuRecord_s &uurRef = it->first;
4219  const returnRow_s &returnRowRef = it->second;
4220  tableRef.unmakerow((string *)&returnRowRef.row,
4221  &fieldValues);
4222 
4223  for (size_t n=0; inValues.size(); n++)
4224  {
4225  if (compareFields(fieldtype, fieldValues[fieldid],
4226  inValues[n])==true)
4227  {
4228  results[uurRef] = returnRowRef;
4229  }
4230  }
4231  }
4232  }
4233  break;
4234 
4235  case OPERATOR_NOTIN:
4236  {
4237  /* do after AST is walkable since inobject contains a vector
4238  * of Ast */
4239  int64_t fieldid;
4240  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4241  vector<fieldValue_s> fieldValues;
4242  class Table &tableRef = *schemaPtr->tables[tableid];
4243  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4244  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4245 
4246  for (it = andResults.begin(); it != andResults.end(); it++)
4247  {
4248  const uuRecord_s &uurRef = it->first;
4249  const returnRow_s &returnRowRef = it->second;
4250  tableRef.unmakerow((string *)&returnRowRef.row,
4251  &fieldValues);
4252  bool notin=true;
4253 
4254  for (size_t n=0; inValues.size(); n++)
4255  {
4256  if (compareFields(fieldtype, fieldValues[fieldid],
4257  inValues[n])==true)
4258  {
4259  notin=false;
4260  break;
4261  }
4262  }
4263 
4264  if (notin==true)
4265  {
4266  results[uurRef] = returnRowRef;
4267  }
4268  }
4269  }
4270  break;
4271 
4272  case OPERATOR_ISNULL:
4273  {
4274  if (lhs.isnull==true)
4275  {
4276  results[uurRef] = returnRowRef;
4277  }
4278  }
4279  break;
4280 
4281  case OPERATOR_ISNOTNULL:
4282  {
4283  if (lhs.isnull==false)
4284  {
4285  results[uurRef] = returnRowRef;
4286  }
4287  }
4288  break;
4289 
4290  default:
4291  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
4292  }
4293  }
4294  break;
4295 
4296  case CHAR:
4297  {
4298  switch (op)
4299  {
4300  case OPERATOR_EQ:
4301  {
4302  char rhsval=rightoperand[1];
4303 
4304  if (lhs.value.character==rhsval)
4305  {
4306  results[uurRef] = returnRowRef;
4307  }
4308  }
4309  break;
4310 
4311  case OPERATOR_NE:
4312  {
4313  char rhsval=rightoperand[1];
4314 
4315  if (lhs.value.character!=rhsval)
4316  {
4317  results[uurRef] = returnRowRef;
4318  }
4319  }
4320  break;
4321 
4322  case OPERATOR_GT:
4323  {
4324  char rhsval=rightoperand[1];
4325 
4326  if (lhs.value.character>rhsval)
4327  {
4328  results[uurRef] = returnRowRef;
4329  }
4330  }
4331  break;
4332 
4333  case OPERATOR_LT:
4334  {
4335  char rhsval=rightoperand[1];
4336 
4337  if (lhs.value.character<rhsval)
4338  {
4339  results[uurRef] = returnRowRef;
4340  }
4341  }
4342  break;
4343 
4344  case OPERATOR_GTE:
4345  {
4346  char rhsval=rightoperand[1];
4347 
4348  if (lhs.value.character>=rhsval)
4349  {
4350  results[uurRef] = returnRowRef;
4351  }
4352  }
4353  break;
4354 
4355  case OPERATOR_LTE:
4356  {
4357  char rhsval=rightoperand[1];
4358 
4359  if (lhs.value.character<=rhsval)
4360  {
4361  results[uurRef] = returnRowRef;
4362  }
4363  }
4364  break;
4365 
4366  case OPERATOR_BETWEEN:
4367  {
4368  char rhsval=rightoperand[1+sizeof(int64_t)];
4369  char rhsval2=rightoperand[1+sizeof(int64_t)+1];
4370 
4371  if (lhs.value.character >= rhsval && lhs.value.character <=
4372  rhsval2)
4373  {
4374  results[uurRef] = returnRowRef;
4375  }
4376  }
4377  break;
4378 
4379  case OPERATOR_NOTBETWEEN:
4380  {
4381  char rhsval=rightoperand[1+sizeof(int64_t)];
4382  char rhsval2=rightoperand[1+sizeof(int64_t)+1];
4383 
4384  if (lhs.value.character < rhsval || lhs.value.character >
4385  rhsval2)
4386  {
4387  results[uurRef] = returnRowRef;
4388  }
4389  }
4390  break;
4391 
4392  case OPERATOR_IN:
4393  {
4394  /* do after AST is walkable since inobject contains a vector
4395  * of Ast */
4396  int64_t fieldid;
4397  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4398  vector<fieldValue_s> fieldValues;
4399  class Table &tableRef = *schemaPtr->tables[tableid];
4400  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4401  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4402 
4403  for (it = andResults.begin(); it != andResults.end(); it++)
4404  {
4405  const uuRecord_s &uurRef = it->first;
4406  const returnRow_s &returnRowRef = it->second;
4407  tableRef.unmakerow((string *)&returnRowRef.row,
4408  &fieldValues);
4409 
4410  for (size_t n=0; inValues.size(); n++)
4411  {
4412  if (compareFields(fieldtype, fieldValues[fieldid],
4413  inValues[n])==true)
4414  {
4415  results[uurRef] = returnRowRef;
4416  }
4417  }
4418  }
4419  }
4420  break;
4421 
4422  case OPERATOR_NOTIN:
4423  {
4424  /* do after AST is walkable since inobject contains a vector
4425  * of Ast */
4426  int64_t fieldid;
4427  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4428  vector<fieldValue_s> fieldValues;
4429  class Table &tableRef = *schemaPtr->tables[tableid];
4430  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4431  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4432 
4433  for (it = andResults.begin(); it != andResults.end(); it++)
4434  {
4435  const uuRecord_s &uurRef = it->first;
4436  const returnRow_s &returnRowRef = it->second;
4437  tableRef.unmakerow((string *)&returnRowRef.row,
4438  &fieldValues);
4439  bool notin=true;
4440 
4441  for (size_t n=0; inValues.size(); n++)
4442  {
4443  if (compareFields(fieldtype, fieldValues[fieldid],
4444  inValues[n])==true)
4445  {
4446  notin=false;
4447  break;
4448  }
4449  }
4450 
4451  if (notin==true)
4452  {
4453  results[uurRef] = returnRowRef;
4454  }
4455  }
4456  }
4457  break;
4458 
4459  case OPERATOR_ISNULL:
4460  {
4461  if (lhs.isnull==true)
4462  {
4463  results[uurRef] = returnRowRef;
4464  }
4465  }
4466  break;
4467 
4468  case OPERATOR_ISNOTNULL:
4469  {
4470  if (lhs.isnull==false)
4471  {
4472  results[uurRef] = returnRowRef;
4473  }
4474  }
4475  break;
4476 
4477  default:
4478  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
4479  }
4480  }
4481  break;
4482 
4483  case CHARX:
4484  {
4485  switch (op)
4486  {
4487  case OPERATOR_EQ:
4488  {
4489  string rhsval=rightoperand.substr(1, string::npos);
4490 
4491  if (!lhs.str.compare(rhsval))
4492  {
4493  results[uurRef] = returnRowRef;
4494  }
4495  }
4496  break;
4497 
4498  case OPERATOR_NE:
4499  {
4500  string rhsval=rightoperand.substr(1, string::npos);
4501 
4502  if (lhs.str.compare(rhsval))
4503  {
4504  results[uurRef] = returnRowRef;
4505  }
4506  }
4507  break;
4508 
4509  case OPERATOR_IN:
4510  {
4511  /* do after AST is walkable since inobject contains a vector
4512  * of Ast */
4513  int64_t fieldid;
4514  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4515  vector<fieldValue_s> fieldValues;
4516  class Table &tableRef = *schemaPtr->tables[tableid];
4517  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4518  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4519 
4520  for (it = andResults.begin(); it != andResults.end(); it++)
4521  {
4522  const uuRecord_s &uurRef = it->first;
4523  const returnRow_s &returnRowRef = it->second;
4524  tableRef.unmakerow((string *)&returnRowRef.row,
4525  &fieldValues);
4526 
4527  for (size_t n=0; inValues.size(); n++)
4528  {
4529  if (compareFields(fieldtype, fieldValues[fieldid],
4530  inValues[n])==true)
4531  {
4532  results[uurRef] = returnRowRef;
4533  }
4534  }
4535  }
4536  }
4537  break;
4538 
4539  case OPERATOR_NOTIN:
4540  {
4541  /* do after AST is walkable since inobject contains a vector
4542  * of Ast */
4543  int64_t fieldid;
4544  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4545  vector<fieldValue_s> fieldValues;
4546  class Table &tableRef = *schemaPtr->tables[tableid];
4547  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4548  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4549 
4550  for (it = andResults.begin(); it != andResults.end(); it++)
4551  {
4552  const uuRecord_s &uurRef = it->first;
4553  const returnRow_s &returnRowRef = it->second;
4554  tableRef.unmakerow((string *)&returnRowRef.row,
4555  &fieldValues);
4556  bool notin=true;
4557 
4558  for (size_t n=0; inValues.size(); n++)
4559  {
4560  if (compareFields(fieldtype, fieldValues[fieldid],
4561  inValues[n])==true)
4562  {
4563  notin=false;
4564  break;
4565  }
4566  }
4567 
4568  if (notin==true)
4569  {
4570  results[uurRef] = returnRowRef;
4571  }
4572  }
4573  }
4574  break;
4575 
4576  case OPERATOR_ISNULL:
4577  {
4578  if (lhs.isnull==true)
4579  {
4580  results[uurRef] = returnRowRef;
4581  }
4582  }
4583  break;
4584 
4585  case OPERATOR_ISNOTNULL:
4586  {
4587  if (lhs.isnull==false)
4588  {
4589  results[uurRef] = returnRowRef;
4590  }
4591  }
4592  break;
4593 
4594  case OPERATOR_LIKE:
4595  {
4596  string rhsval=rightoperand.substr(1, string::npos);
4597  like2Regex(rhsval);
4598  pcrecpp::RE re(rhsval);
4599 
4600  if (re.FullMatch(lhs.str)==true)
4601  {
4602  results[uurRef] = returnRowRef;
4603  }
4604  }
4605  break;
4606 
4607  case OPERATOR_NOTLIKE:
4608  {
4609  string rhsval=rightoperand.substr(1, string::npos);
4610  like2Regex(rhsval);
4611  pcrecpp::RE re(rhsval);
4612  rhsval.insert(0, "^((?!");
4613  rhsval.append(").)*$");
4614 
4615  if (re.FullMatch(lhs.str)==true)
4616  {
4617  results[uurRef] = returnRowRef;
4618  }
4619  }
4620  break;
4621 
4622  default:
4623  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
4624  }
4625  }
4626  break;
4627 
4628  case VARCHAR:
4629  {
4630  switch (op)
4631  {
4632  case OPERATOR_EQ:
4633  {
4634  string rhsval=rightoperand.substr(1, string::npos);
4635 
4636  if (!lhs.str.compare(rhsval))
4637  {
4638  results[uurRef] = returnRowRef;
4639  }
4640  }
4641  break;
4642 
4643  case OPERATOR_NE:
4644  {
4645  string rhsval=rightoperand.substr(1, string::npos);
4646 
4647  if (lhs.str.compare(rhsval))
4648  {
4649  results[uurRef] = returnRowRef;
4650  }
4651  }
4652  break;
4653 
4654  case OPERATOR_IN:
4655  {
4656  /* do after AST is walkable since inobject contains a vector
4657  * of Ast */
4658  int64_t fieldid;
4659  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4660  vector<fieldValue_s> fieldValues;
4661  class Table &tableRef = *schemaPtr->tables[tableid];
4662  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4663  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4664 
4665  for (it = andResults.begin(); it != andResults.end(); it++)
4666  {
4667  const uuRecord_s &uurRef = it->first;
4668  const returnRow_s &returnRowRef = it->second;
4669  tableRef.unmakerow((string *)&returnRowRef.row,
4670  &fieldValues);
4671 
4672  for (size_t n=0; inValues.size(); n++)
4673  {
4674  if (compareFields(fieldtype, fieldValues[fieldid],
4675  inValues[n])==true)
4676  {
4677  results[uurRef] = returnRowRef;
4678  }
4679  }
4680  }
4681  }
4682  break;
4683 
4684  case OPERATOR_NOTIN:
4685  {
4686  /* do after AST is walkable since inobject contains a vector
4687  * of Ast */
4688  int64_t fieldid;
4689  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
4690  vector<fieldValue_s> fieldValues;
4691  class Table &tableRef = *schemaPtr->tables[tableid];
4692  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
4693  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
4694 
4695  for (it = andResults.begin(); it != andResults.end(); it++)
4696  {
4697  const uuRecord_s &uurRef = it->first;
4698  const returnRow_s &returnRowRef = it->second;
4699  tableRef.unmakerow((string *)&returnRowRef.row,
4700  &fieldValues);
4701  bool notin=true;
4702 
4703  for (size_t n=0; inValues.size(); n++)
4704  {
4705  if (compareFields(fieldtype, fieldValues[fieldid],
4706  inValues[n])==true)
4707  {
4708  notin=false;
4709  break;
4710  }
4711  }
4712 
4713  if (notin==true)
4714  {
4715  results[uurRef] = returnRowRef;
4716  }
4717  }
4718  }
4719  break;
4720 
4721  case OPERATOR_ISNULL:
4722  {
4723  if (lhs.isnull==true)
4724  {
4725  results[uurRef] = returnRowRef;
4726  }
4727  }
4728  break;
4729 
4730  case OPERATOR_ISNOTNULL:
4731  {
4732  if (lhs.isnull==false)
4733  {
4734  results[uurRef] = returnRowRef;
4735  }
4736  }
4737  break;
4738 
4739  case OPERATOR_LIKE:
4740  {
4741  string rhsval=rightoperand.substr(1, string::npos);
4742  like2Regex(rhsval);
4743  pcrecpp::RE re(rhsval);
4744 
4745  if (re.FullMatch(lhs.str)==true)
4746  {
4747  results[uurRef] = returnRowRef;
4748  }
4749  }
4750  break;
4751 
4752  case OPERATOR_NOTLIKE:
4753  {
4754  string rhsval=rightoperand.substr(1, string::npos);
4755  like2Regex(rhsval);
4756  pcrecpp::RE re(rhsval);
4757  rhsval.insert(0, "^((?!");
4758  rhsval.append(").)*$");
4759 
4760  if (re.FullMatch(lhs.str)==true)
4761  {
4762  results[uurRef] = returnRowRef;
4763  }
4764  }
4765  break;
4766 
4767  default:
4768  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
4769  }
4770  }
4771  break;
4772 
4773  default:
4774  fprintf(logfile, "anomaly: %i %s %i\n",
4775  tableRef.fields[fieldid].type, __FILE__, __LINE__);
4776  }
4777  }
4778 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::branchtotype ( )

SELECT, INSERT, UPDATE, DELETE, stored proc branch to.

Definition at line 4908 of file Asts.cc.

References APISTATUS_NOTOK, APISTATUS_NULLCONSTRAINT, APISTATUS_PENDING, BOOL, fieldInput_u::boolean, CHAR, fieldInput_u::character, CHARX, CMD_BEGIN, CMD_COMMIT, CMD_DELETE, CMD_INSERT, CMD_ROLLBACK, CMD_SELECT, CMD_STOREDPROCEDURE, CMD_UPDATE, continueDelete(), continueSelect(), continueUpdate(), currentQuery, Schema::domainid, TransactionAgent::domainidsToProcedures, Table::fields, FLOAT, Transaction::getengine(), Transaction::getnextpendingcmdid(), Statement::query_s::haswhere, Field::indextype, Statement::query_s::insertColumns, Statement::results_s::insertValues, INT, fieldInput_u::integer, fieldValue_s::isnull, Statement::query_s::locktype, Table::makerow(), Statement::results_s::newrow, NEWROW, Statement::results_s::newrowengineid, NOCOMMAND, NONUNIQUENOTNULL, Ast::operand, OPERAND_NULL, PAYLOADSUBTRANSACTION, Transaction::pendingcmd, Transaction::pendingcmdid, PRIMITIVE_SQLINSERT, PRIMITIVE_SQLSELECTALL, PRIMITIVE_SQLSELECTALLFORDELETE, PRIMITIVE_SQLSELECTALLFORUPDATE, procedures_s::procedurecreator, procedures_s::proceduredestroyer, reenter(), reentry, Statement::reentry_s::reentryObject, Statement::query_s::results, ApiInterface::results, MessageSubtransactionCmd::row, schemaPtr, searchExpression(), Statement::results_s::searchResults, Transaction::sendTransaction(), Transaction::sqlcmdstate, Transaction::sqlSelectAll(), stagedRow2ReturnRow(), Transaction::stagedRows, startQuery(), Transaction::sqlcmdstate_s::statement, STATUS_NOTOK, Statement::query_s::storedProcedure, fieldValue_s::str, MessageSubtransactionCmd::subtransactionStruct, Transaction::sqlcmdstate_s::tableid, Statement::query_s::tableid, MessageSubtransactionCmd::subtransaction_s::tableid, Schema::tables, taPtr, Ast::toFloat(), transactionPtr, Statement::query_s::type, UINT, fieldInput_u::uinteger, UNIQUENOTNULL, UNORDEREDNOTNULL, fieldValue_s::value, VARCHAR, and WRITELOCK.

Referenced by searchExpression(), and startQuery().

4909 {
4910  switch (currentQuery->type)
4911  {
4912  case CMD_SELECT:
4913  {
4914  if (currentQuery->haswhere==false)
4915  {
4916  /* select everything, checking existing staged rows first */
4917  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
4918 
4919  for (it = transactionPtr->stagedRows.begin();
4920  it != transactionPtr->stagedRows.end(); it++)
4921  {
4922  const uuRecord_s &uurRef = it->first;
4923  const stagedRow_s &stagedRowRef = it->second;
4924  returnRow_s returnRow;
4925  stagedRow2ReturnRow(stagedRowRef, returnRow);
4926  currentQuery->results.searchResults[uurRef]=returnRow;
4927  }
4928 
4929  transactionPtr->sqlSelectAll(this, currentQuery->tableid,
4930  currentQuery->locktype,
4931  PRIMITIVE_SQLSELECTALL,
4932  currentQuery->results.searchResults);
4933  }
4934  else
4935  {
4936  continueSelect(1, NULL);
4937  }
4938  }
4939  break;
4940 
4941  case CMD_INSERT:
4942  {
4943  class Table &tableRef = *schemaPtr->tables[currentQuery->tableid];
4944 
4945  size_t numfields = currentQuery->insertColumns.size();
4946  currentQuery->results.insertValues.reserve(numfields);
4947 
4948  for (size_t n=0; n < numfields; n++)
4949  {
4950  fieldValue_s fieldValue = {};
4951  class Ast &astRef = *currentQuery->insertColumns[numfields-1-n];
4952  searchExpression(0, &astRef);
4953 
4954  if (astRef.operand[0]==OPERAND_NULL)
4955  {
4956  class Field &fieldRef =
4957  tableRef.fields[n];
4958 
4959  if (fieldRef.indextype==UNIQUENOTNULL ||
4960  fieldRef.indextype==NONUNIQUENOTNULL ||
4961  fieldRef.indextype==UNORDEREDNOTNULL)
4962  {
4963  reenter(APISTATUS_NULLCONSTRAINT);
4964  return;
4965  }
4966 
4967  fieldValue.isnull=true;
4968  currentQuery->results.insertValues.push_back(fieldValue);
4969  }
4970  else
4971  {
4972  switch (tableRef.fields[n].type)
4973  {
4974  case INT:
4975  memcpy(&fieldValue.value.integer, &astRef.operand[1],
4976  sizeof(int64_t));
4977  currentQuery->results.insertValues.push_back(fieldValue);
4978  break;
4979 
4980  case UINT:
4981  memcpy(&fieldValue.value.uinteger, &astRef.operand[1],
4982  sizeof(int64_t));
4983  currentQuery->results.insertValues.push_back(fieldValue);
4984  break;
4985 
4986  case BOOL:
4987  if (astRef.operand[1]=='t')
4988  {
4989  fieldValue.value.boolean=true;
4990  }
4991  else
4992  {
4993  fieldValue.value.boolean=false;
4994  }
4995 
4996  currentQuery->results.insertValues.push_back(fieldValue);
4997  break;
4998 
4999  case FLOAT:
5000  Ast::toFloat(astRef.operand, fieldValue);
5001  currentQuery->results.insertValues.push_back(fieldValue);
5002  break;
5003 
5004  case CHAR:
5005  fieldValue.value.character=astRef.operand[1];
5006  currentQuery->results.insertValues.push_back(fieldValue);
5007  break;
5008 
5009  case CHARX:
5010  fieldValue.str=astRef.operand.substr(1, string::npos);
5011  currentQuery->results.insertValues.push_back(fieldValue);
5012  break;
5013 
5014  case VARCHAR:
5015  fieldValue.str=astRef.operand.substr(1, string::npos);
5016  currentQuery->results.insertValues.push_back(fieldValue);
5017  break;
5018 
5019  default:
5020  printf("%s %i anomaly %i\n", __FILE__, __LINE__,
5021  tableRef.fields[n].type);
5022  }
5023  }
5024  }
5025 
5026  if (tableRef.makerow(&currentQuery->results.insertValues,
5027  &currentQuery->results.newrow)==false)
5028  {
5029  reenter(APISTATUS_NOTOK);
5030  }
5031 
5032  currentQuery->results.newrowengineid = transactionPtr->getengine(
5033  tableRef.fields[0].type, currentQuery->results.insertValues[0]);
5034 
5035  if (transactionPtr->pendingcmd != NOCOMMAND)
5036  {
5037  reenter(APISTATUS_PENDING);
5038  return;
5039  }
5040 
5041  transactionPtr->pendingcmdid = transactionPtr->getnextpendingcmdid();
5042  transactionPtr->pendingcmd = PRIMITIVE_SQLINSERT;
5043  transactionPtr->sqlcmdstate = (Transaction::sqlcmdstate_s)
5044  {
5045  0
5046  };
5047  transactionPtr->sqlcmdstate.statement=this;
5048  transactionPtr->sqlcmdstate.tableid = currentQuery->tableid;
5049 
5050  class MessageSubtransactionCmd *msg =
5051  new class MessageSubtransactionCmd();
5052  class MessageSubtransactionCmd &msgref = *msg;
5053  msgref.subtransactionStruct.tableid = currentQuery->tableid;
5054  msgref.row = currentQuery->results.newrow;
5055  transactionPtr->sendTransaction(NEWROW, PAYLOADSUBTRANSACTION, 1,
5056  currentQuery->results.newrowengineid,
5057  msg);
5058  }
5059  break;
5060 
5061  case CMD_UPDATE:
5062  {
5063  if (currentQuery->haswhere==false)
5064  {
5065  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
5066 
5067  for (it = transactionPtr->stagedRows.begin();
5068  it != transactionPtr->stagedRows.end(); it++)
5069  {
5070  const uuRecord_s &uurRef = it->first;
5071  const stagedRow_s &stagedRowRef = it->second;
5072  returnRow_s returnRow;
5073  stagedRow2ReturnRow(stagedRowRef, returnRow);
5074  currentQuery->results.searchResults[uurRef]=returnRow;
5075  }
5076 
5077  transactionPtr->sqlSelectAll(this, currentQuery->tableid, WRITELOCK,
5078  PRIMITIVE_SQLSELECTALLFORUPDATE,
5079  currentQuery->results.searchResults);
5080  return;
5081  }
5082  else
5083  {
5084  continueUpdate(1, NULL);
5085  }
5086  }
5087  break;
5088 
5089  case CMD_DELETE:
5090  {
5091  if (currentQuery->haswhere==false)
5092  {
5093  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
5094 
5095  for (it = transactionPtr->stagedRows.begin();
5096  it != transactionPtr->stagedRows.end(); it++)
5097  {
5098  const uuRecord_s &uurRef = it->first;
5099  const stagedRow_s &stagedRowRef = it->second;
5100  returnRow_s returnRow;
5101  stagedRow2ReturnRow(stagedRowRef, returnRow);
5102  currentQuery->results.searchResults[uurRef]=returnRow;
5103  }
5104 
5105  transactionPtr->sqlSelectAll(this, currentQuery->tableid, WRITELOCK,
5106  PRIMITIVE_SQLSELECTALLFORDELETE,
5107  currentQuery->results.searchResults);
5108  }
5109  else
5110  {
5111  continueDelete(1, NULL);
5112  }
5113  }
5114  break;
5115 
5116  case CMD_STOREDPROCEDURE:
5117  {
5118  reentry.reentryObject->results.cmdtype = CMD_STOREDPROCEDURE;
5119 
5120  if (taPtr->domainidsToProcedures.count(schemaPtr->domainid))
5121  {
5122  domainProceduresMap &procsMapRef =
5123  taPtr->domainidsToProcedures[schemaPtr->domainid];
5124 
5125  if (procsMapRef.count(currentQuery->storedProcedure))
5126  {
5127  procedures_s &proceduresRef =
5128  procsMapRef[currentQuery->storedProcedure];
5129  spclasscreate spC =
5130  (spclasscreate)proceduresRef.procedurecreator;
5131  spclasscreate spD =
5132  (spclasscreate)proceduresRef.proceduredestroyer;
5133  // make sure to delete this statement in the procedure!
5134  spC(NULL, reentry.reentryObject, (void *)spD);
5135  }
5136  else
5137  {
5138  reenter(STATUS_NOTOK);
5139  return;
5140  }
5141  }
5142  else
5143  {
5144  reenter(STATUS_NOTOK);
5145  return;
5146  }
5147  }
5148  break;
5149 
5150  case CMD_BEGIN:
5151  startQuery();
5152  break;
5153 
5154  case CMD_COMMIT:
5155  startQuery();
5156  break;
5157 
5158  case CMD_ROLLBACK:
5159  startQuery();
5160  break;
5161 
5162  default:
5163  printf("%s %i unhandled statement type %i\n", __FILE__, __LINE__,
5164  currentQuery->type);
5165  reenter(STATUS_NOTOK);
5166  return;
5167  }
5168 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::continueDelete ( int64_t  entrypoint,
class Ast *  ignorethis 
)

continuation for DELETE statement

Parameters
entrypoint
ignorethis

Definition at line 5230 of file Asts.cc.

References stagedRow_s::cmd, currentQuery, DELETE, DELETEROW, uuRecord_s::engineid, MessageSubtransactionCmd::subtransaction_s::engineid, Transaction::sqlcmdstate_s::eventwaitcount, Transaction::getnextpendingcmdid(), stagedRow_s::originalRow, PAYLOADSUBTRANSACTION, Transaction::pendingcmd, Transaction::pendingcmdid, PRIMITIVE_SQLDELETE, Statement::query_s::results, returnRow_s::row, uuRecord_s::rowid, MessageSubtransactionCmd::subtransaction_s::rowid, Statement::results_s::searchResults, Transaction::sendTransaction(), Transaction::sqlcmdstate, Transaction::stagedRows, startQuery(), Transaction::sqlcmdstate_s::statement, MessageSubtransactionCmd::subtransactionStruct, uuRecord_s::tableid, MessageSubtransactionCmd::subtransaction_s::tableid, and transactionPtr.

Referenced by branchtotype(), Transaction::continueSqlDelete(), and Transaction::continueSqlPredicate().

5231 {
5232  switch (entrypoint)
5233  {
5234  case 1:
5235  {
5236  transactionPtr->sqlcmdstate = (Transaction::sqlcmdstate_s)
5237  {
5238  0
5239  };
5240  transactionPtr->sqlcmdstate.statement=this;
5241  transactionPtr->pendingcmdid = transactionPtr->getnextpendingcmdid();
5242  transactionPtr->pendingcmd = PRIMITIVE_SQLDELETE;
5243 
5244  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
5245 
5246  for (it = currentQuery->results.searchResults.begin();
5247  it != currentQuery->results.searchResults.end(); it++)
5248  {
5249  const uuRecord_s &uurRef = it->first;
5250  const returnRow_s &returnRowRef = it->second;
5251  class MessageSubtransactionCmd *msg =
5252  new class MessageSubtransactionCmd();
5253  msg->subtransactionStruct.tableid = uurRef.tableid;
5254  msg->subtransactionStruct.rowid = uurRef.rowid;
5255  msg->subtransactionStruct.engineid = uurRef.engineid;
5256  transactionPtr->sendTransaction(DELETEROW, PAYLOADSUBTRANSACTION, 1,
5257  uurRef.engineid, msg);
5258  stagedRow_s &stagedRowRef = transactionPtr->stagedRows[uurRef];
5259  stagedRowRef.cmd=DELETE;
5260  stagedRowRef.originalRow=returnRowRef.row;
5261  transactionPtr->stagedRows[uurRef].cmd=DELETE;
5262  }
5263 
5264  transactionPtr->sqlcmdstate.eventwaitcount =
5265  currentQuery->results.searchResults.size();
5266  }
5267  break;
5268 
5269  case 2:
5270  startQuery();
5271  break;
5272 
5273  default:
5274  printf("%s %i anomaly %li\n", __FILE__, __LINE__, entrypoint);
5275  }
5276 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::continueInsert ( int64_t  entrypoint,
class Ast *  ignorethis 
)

continuation for INSERT statement

Parameters
entrypoint
ignorethis

Definition at line 5517 of file Asts.cc.

References startQuery().

Referenced by Transaction::continueSqlInsert().

5518 {
5519  startQuery();
5520 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::continueSelect ( int64_t  entrypoint,
class Ast *  ignorethis 
)

continuation for SELECT statement

Parameters
entrypoint
ignorethis

Definition at line 5190 of file Asts.cc.

References stagedRow_s::cmd, currentQuery, Statement::query_s::fromColumnids, returnRow_s::locktype, stagedRow_s::locktype, NOCOMMAND, stagedRow_s::originalRow, stagedRow_s::originalrowid, Statement::query_s::results, returnRow_s::row, returnRow_s::rowid, schemaPtr, Statement::results_s::searchResults, Statement::results_s::selectResults, Transaction::stagedRows, startQuery(), Statement::query_s::tableid, Schema::tables, transactionPtr, and Table::unmakerow().

Referenced by branchtotype(), Transaction::continueSqlPredicate(), and Transaction::sqlSelectAll().

5191 {
5192  /* there should be nothing special to do for selectall vs predicate search
5193  * because the searchResults have already been populated
5194  */
5195  class Table &tableRef = *schemaPtr->tables[currentQuery->tableid];
5196 
5197  boost::unordered_map<uuRecord_s, returnRow_s>::const_iterator it;
5198 
5199  for (it = currentQuery->results.searchResults.begin();
5200  it != currentQuery->results.searchResults.end(); it++)
5201  {
5202  const uuRecord_s &uurRef = it->first;
5203  const returnRow_s &returnRowRef = it->second;
5204  vector<fieldValue_s> foundFields;
5205  tableRef.unmakerow((string *)&returnRowRef.row, &foundFields);
5206  vector<fieldValue_s> returnFields;
5207 
5208  for (size_t n=0; n < currentQuery->fromColumnids.size(); n++)
5209  {
5210  returnFields.push_back(foundFields[currentQuery->fromColumnids[n].fieldid]);
5211  }
5212 
5213  currentQuery->results.selectResults[uurRef] = returnFields;
5214 
5215  if (!transactionPtr->stagedRows.count(uurRef))
5216  {
5217  stagedRow_s srow = {};
5218  srow.cmd=NOCOMMAND;
5219  srow.locktype=returnRowRef.locktype;
5220  srow.originalRow=returnRowRef.row;
5221  srow.originalrowid=returnRowRef.rowid;
5222 
5223  transactionPtr->stagedRows[uurRef]=srow;
5224  }
5225  }
5226 
5227  startQuery();
5228 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::continueUpdate ( int64_t  entrypoint,
class Ast *  ignorethis 
)

continuation for UPDATE statement

Parameters
entrypoint
ignorethis

Definition at line 5278 of file Asts.cc.

References abortQuery(), APISTATUS_PENDING, BOOL, fieldInput_u::boolean, CHAR, fieldInput_u::character, CHARX, stagedRow_s::cmd, currentQuery, uuRecord_s::engineid, MessageSubtransactionCmd::subtransaction_s::engineid, lockFieldValue_s::engineid, Transaction::sqlcmdstate_s::eventwaitcount, MessageSubtransactionCmd::subtransaction_s::fieldid, Statement::query_s::fieldidAssignments, Table::fields, lockFieldValue_s::fieldVal, MessageSubtransactionCmd::fieldVal, FLOAT, Transaction::getengine(), Transaction::getnextpendingcmdid(), Field::index, INDEXLOCK, INT, fieldInput_u::integer, fieldValue_s::isnull, MessageSubtransactionCmd::subtransaction_s::isrow, Index::isunique, lockFieldValue_s::locktype, stagedRow_s::locktype, Table::makerow(), stagedRow_s::newengineid, NEWROW, stagedRow_s::newRow, Statement::results_s::newrowengineid, stagedRow_s::newrowid, NOCOMMAND, OPERAND_NULL, stagedRow_s::originalengineid, stagedRow_s::originalRow, stagedRow_s::originalrowid, Statement::results_s::originalrowuur, PAYLOADSUBTRANSACTION, Transaction::pendingcmd, Transaction::pendingcmdid, returnRow_s::previoussubtransactionid, stagedRow_s::previoussubtransactionid, PRIMITIVE_SQLREPLACE, PRIMITIVE_SQLUPDATE, Statement::query_s::results, returnRow_s::row, MessageSubtransactionCmd::row, uuRecord_s::rowid, MessageSubtransactionCmd::subtransaction_s::rowid, schemaPtr, Statement::results_s::searchResults, Transaction::sendTransaction(), Statement::results_s::setFields, Transaction::sqlcmdstate, Transaction::stagedRows, startQuery(), Transaction::sqlcmdstate_s::statement, fieldValue_s::str, MessageSubtransactionCmd::subtransactionStruct, uuRecord_s::tableid, Statement::query_s::tableid, MessageSubtransactionCmd::subtransaction_s::tableid, Schema::tables, Ast::toFloat(), transactionPtr, Field::type, UINT, fieldInput_u::uinteger, UNIQUEINDEX, stagedRow_s::uniqueIndices, Table::unmakerow(), UPDATE, Statement::results_s::updateIterator, UPDATEROW, fieldValue_s::value, VARCHAR, and WRITELOCK.

Referenced by branchtotype(), Transaction::continueSqlPredicate(), Transaction::continueSqlReplace(), and Transaction::continueSqlUpdate().

5279 {
5280  switch (entrypoint)
5281  {
5282  case 1:
5283  {
5284  /* walk through each search result, doing update on each one
5285  * and calling Ast::evaluateAssignment(fieldValues) for each
5286  * field to modify
5287  */
5288  currentQuery->results.updateIterator=
5289  currentQuery->results.searchResults.begin();
5290  }
5291 
5292  // break; fall right through
5293 
5294  case 2:
5295  {
5296  /* walk through each search result, doing update on each one
5297  * and calling Ast::evaluateAssignment(fieldValues) for each
5298  * field to modify
5299  */
5300  if (transactionPtr->pendingcmd != NOCOMMAND)
5301  {
5302  printf("%s %i APISTATUS_PENDING pendingcmd %i\n", __FILE__, __LINE__, transactionPtr->pendingcmd);
5303  abortQuery(APISTATUS_PENDING);
5304  return;
5305  }
5306 
5307  transactionPtr->pendingcmdid = transactionPtr->getnextpendingcmdid();
5308  transactionPtr->sqlcmdstate = (Transaction::sqlcmdstate_s)
5309  {
5310  0
5311  };
5312  transactionPtr->sqlcmdstate.statement=this;
5313 
5314  class Table &tableRef = *schemaPtr->tables[currentQuery->tableid];
5315 
5316  if (currentQuery->results.updateIterator !=
5317  currentQuery->results.searchResults.end())
5318  {
5319  vector<fieldValue_s> fieldValues;
5320  const returnRow_s &returnRowRef=
5321  currentQuery->results.updateIterator->second;
5322  tableRef.unmakerow((string *)&returnRowRef.row, &fieldValues);
5323 
5324  // do update stuff
5325  // boost::unordered_map<int64_t, class Ast *> fieldidAssignments
5326  boost::unordered_map<int64_t, class Ast *>::iterator it;
5327 
5328  for (it = currentQuery->fieldidAssignments.begin();
5329  it != currentQuery->fieldidAssignments.end(); it++)
5330  {
5331  it->second->evaluateAssignment(fieldValues, this);
5332  // fieldid is it->first; class Ast * is it->second;
5333  class Field &fieldRef = tableRef.fields[it->first];
5334  fieldValue_s fieldValue = {};
5335 
5336  if (it->second->operand[0]==OPERAND_NULL)
5337  {
5338  fieldValue.isnull=true;
5339  }
5340  else
5341  {
5342  switch (fieldRef.type)
5343  {
5344  case INT:
5345  memcpy(&fieldValue.value.integer,
5346  &it->second->operand[1],
5347  sizeof(int64_t));
5348  break;
5349 
5350  case UINT:
5351  memcpy(&fieldValue.value.uinteger,
5352  &it->second->operand[1],
5353  sizeof(int64_t));
5354  break;
5355 
5356  case BOOL:
5357  {
5358  int64_t boolval;
5359  memcpy(&boolval, &it->second->operand[1],
5360  sizeof(int64_t));
5361  fieldValue.value.boolean = (bool)boolval;
5362  }
5363  break;
5364 
5365  case FLOAT:
5366  Ast::toFloat(it->second->operand, fieldValue);
5367  break;
5368 
5369  case CHAR:
5370  fieldValue.value.character=it->second->operand[1];
5371  break;
5372 
5373  case CHARX:
5374  fieldValue.str=it->second->operand.substr(1,
5375  string::npos);
5376  break;
5377 
5378  case VARCHAR:
5379  fieldValue.str=it->second->operand.substr(1,
5380  string::npos);
5381  break;
5382 
5383  default:
5384  printf("%s %i anomaly %i\n", __FILE__, __LINE__,
5385  tableRef.fields[it->first].type);
5386  return;
5387  }
5388  }
5389 
5390  currentQuery->results.setFields[it->first]=fieldValue;
5391  }
5392 
5393  const uuRecord_s &uurRef=
5394  currentQuery->results.updateIterator->first;
5395 
5396  if (!currentQuery->results.setFields.count(0))
5397  {
5398  // update
5399  transactionPtr->pendingcmd = PRIMITIVE_SQLUPDATE;
5400  stagedRow_s stagedRow= {};
5401  vector<fieldValue_s> fieldValues;
5402  tableRef.unmakerow((string *)&returnRowRef.row, &fieldValues);
5403 
5404  for (size_t n=0; n < fieldValues.size(); n++)
5405  {
5406  class Field &fieldRef = tableRef.fields[n];
5407 
5408  if (currentQuery->results.setFields.count(n))
5409  {
5410  fieldValues[n] = currentQuery->results.setFields[n];
5411 
5412  // index stuff
5413  if (fieldRef.index.isunique==true)
5414  {
5415  lockFieldValue_s lockFieldValue = {};
5416  lockFieldValue.engineid =
5417  transactionPtr->getengine(fieldRef.type,
5418  fieldValues[n]);
5419  // locktype could potentially change
5420  lockFieldValue.locktype = INDEXLOCK;
5421  lockFieldValue.fieldVal = fieldValues[n];
5422  stagedRow.uniqueIndices[n]=lockFieldValue;
5423 
5424  transactionPtr->sqlcmdstate.eventwaitcount++;
5425  class MessageSubtransactionCmd *msg =
5426  new class MessageSubtransactionCmd();
5427  msg->subtransactionStruct.isrow = false;
5428  msg->subtransactionStruct.tableid = uurRef.tableid;
5429  msg->subtransactionStruct.rowid = uurRef.rowid;
5430  msg->subtransactionStruct.engineid = uurRef.engineid;
5431  msg->subtransactionStruct.fieldid = n;
5432  msg->fieldVal = lockFieldValue.fieldVal;
5433  transactionPtr->sendTransaction(UNIQUEINDEX,
5434  PAYLOADSUBTRANSACTION,
5435  1,
5436  lockFieldValue.engineid,
5437  msg);
5438  }
5439  }
5440  }
5441 
5442  stagedRow.originalRow=returnRowRef.row;
5443  stagedRow.originalrowid=uurRef.rowid;
5444  stagedRow.newrowid=uurRef.rowid;
5445  stagedRow.previoussubtransactionid=
5446  returnRowRef.previoussubtransactionid;
5447  stagedRow.locktype=WRITELOCK;
5448  stagedRow.originalengineid=uurRef.engineid;
5449  stagedRow.newengineid=uurRef.engineid;
5450  tableRef.makerow(&fieldValues, &stagedRow.newRow);
5451  stagedRow.cmd=UPDATE;
5452  transactionPtr->stagedRows[uurRef]=stagedRow;
5453 
5454  transactionPtr->sqlcmdstate.eventwaitcount++;
5455  class MessageSubtransactionCmd *msg =
5456  new class MessageSubtransactionCmd();
5457  msg->subtransactionStruct.tableid = uurRef.tableid;
5458  msg->subtransactionStruct.rowid = uurRef.rowid;
5459  msg->row = stagedRow.newRow;
5460  transactionPtr->sendTransaction(UPDATEROW, PAYLOADSUBTRANSACTION,
5461  1, uurRef.engineid, msg);
5462  }
5463  else
5464  {
5465  //replace
5466  stagedRow_s &stagedRowRef = transactionPtr->stagedRows[uurRef];
5467  stagedRowRef.cmd=UPDATE;
5468  stagedRowRef.originalRow=returnRowRef.row;
5469  stagedRowRef.originalrowid=uurRef.rowid;
5470  stagedRowRef.originalengineid=uurRef.engineid;
5471  stagedRowRef.previoussubtransactionid=
5472  returnRowRef.previoussubtransactionid;
5473  stagedRowRef.locktype=WRITELOCK;
5474 
5475  transactionPtr->pendingcmd = PRIMITIVE_SQLREPLACE;
5476  currentQuery->results.originalrowuur = uurRef;
5477  vector<fieldValue_s> fieldValues;
5478  tableRef.unmakerow((string *)&returnRowRef.row, &fieldValues);
5479 
5480  for (size_t n=0; n < fieldValues.size(); n++)
5481  {
5482  if (currentQuery->results.setFields.count(n))
5483  {
5484  fieldValues[n] = currentQuery->results.setFields[n];
5485  }
5486  }
5487 
5488  tableRef.makerow(&fieldValues, &stagedRowRef.newRow);
5489  currentQuery->results.newrowengineid =
5490  transactionPtr->getengine(tableRef.fields[0].type,
5491  fieldValues[0]);
5492  stagedRowRef.newengineid=currentQuery->results.newrowengineid;
5493 
5494  class MessageSubtransactionCmd *msg =
5495  new class MessageSubtransactionCmd();
5496  class MessageSubtransactionCmd &msgref = *msg;
5497  msgref.subtransactionStruct.tableid = currentQuery->tableid;
5498  msgref.row = stagedRowRef.newRow;
5499  transactionPtr->sendTransaction(NEWROW, PAYLOADSUBTRANSACTION, 1,
5500  stagedRowRef.newengineid, msg);
5501  }
5502 
5503  currentQuery->results.updateIterator++;
5504 
5505  return;
5506  }
5507 
5508  startQuery();
5509  }
5510  break;
5511 
5512  default:
5513  printf("%s %i anomaly %li\n", __FILE__, __LINE__, entrypoint);
5514  }
5515 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::cp ( const Statement &  orig)

deep copy of Statement

Parameters
origsource Statement

Definition at line 2013 of file Asts.cc.

References cpquery(), currentQuery, parameters, queries, queryindex, reentry, schemaPtr, taPtr, and transactionPtr.

Referenced by operator=(), and Statement().

2014 {
2015  taPtr = orig.taPtr;
2016  schemaPtr = orig.schemaPtr;
2017  reentry = orig.reentry;
2018  transactionPtr = orig.transactionPtr;
2019  currentQuery = orig.currentQuery;
2020 
2021  for (size_t n=0; n < orig.queries.size(); n++)
2022  {
2023  queries.push_back(cpquery(orig.queries[n]));
2024  }
2025 
2026  parameters = orig.parameters;
2027  queryindex = orig.queryindex;
2028 }

Here is the call graph for this function:

Here is the caller graph for this function:

Statement::query_s Statement::cpquery ( const query_s &  orig)

deep copy of query_s instance

Parameters
origsource query_s
Returns
new query_s

Definition at line 2030 of file Asts.cc.

References Statement::inobject_s::expressionlist, Statement::query_s::fieldidAssignments, Statement::query_s::fromColumnids, Statement::query_s::fromColumns, Statement::query_s::groupByList, Statement::query_s::hasgroupby, Statement::query_s::hashaving, Statement::query_s::hasnolock, Statement::query_s::hasorderby, Statement::query_s::haswhere, Statement::query_s::inobject, Statement::query_s::insertColumns, Statement::query_s::instance, Statement::query_s::isforupdate, Statement::inobject_s::issubquery, Statement::query_s::locktype, Statement::query_s::orderbylist, Statement::query_s::searchCondition, Statement::inobject_s::subquery, Statement::query_s::table, Statement::query_s::tableid, and Statement::query_s::type.

Referenced by cp().

2031 {
2032  query_s newstmt;
2033 
2034  newstmt.instance = orig.instance;
2035  newstmt.type = orig.type;
2036  newstmt.isforupdate = orig.isforupdate;
2037  newstmt.hasnolock = orig.hasnolock;
2038  newstmt.haswhere = orig.haswhere;
2039  newstmt.hasgroupby= orig.hasgroupby;
2040  newstmt.hashaving = orig.hashaving;
2041  newstmt.hasorderby = orig.hasorderby;
2042  newstmt.table = orig.table;
2043  newstmt.tableid = orig.tableid;
2044  newstmt.locktype = orig.locktype;
2045  newstmt.groupByList = orig.groupByList;
2046  newstmt.fromColumns = orig.fromColumns;
2047  newstmt.fromColumnids = orig.fromColumnids;
2048  newstmt.orderbylist = orig.orderbylist;
2049 
2050  newstmt.inobject.issubquery = orig.inobject.issubquery;
2051  newstmt.inobject.subquery = orig.inobject.subquery;
2052  size_t siz = orig.inobject.expressionlist.size();
2053  newstmt.inobject.expressionlist.resize(siz, NULL);
2054 
2055  for (size_t n=0; n < siz; n++)
2056  {
2057  newstmt.inobject.expressionlist[n] = new class Ast;
2058  *newstmt.inobject.expressionlist[n] = *orig.inobject.expressionlist[n];
2059  }
2060 
2061  if (orig.searchCondition != NULL)
2062  {
2063  newstmt.searchCondition = new class Ast;
2064  *newstmt.searchCondition = *orig.searchCondition;
2065  }
2066  else
2067  {
2068  newstmt.searchCondition=NULL;
2069  }
2070 
2071  /* don't copy assignments, as fieldid assumedly has already been
2072  * resolved, and it makes keeping track of new Ast * objects difficult
2073  */
2074 
2075  boost::unordered_map<int64_t, class Ast *>::const_iterator it;
2076 
2077  for (it = orig.fieldidAssignments.begin();
2078  it != orig.fieldidAssignments.end(); it++)
2079  {
2080 
2081  newstmt.fieldidAssignments[it->first] = new class Ast;
2082  *newstmt.fieldidAssignments[it->first] = *it->second;
2083  }
2084 
2085  for (size_t n=0; n < orig.insertColumns.size(); n++)
2086  {
2087  newstmt.insertColumns.push_back(new class Ast);
2088  *newstmt.insertColumns[n] = *orig.insertColumns[n];
2089  }
2090 
2091  /* results should not need to be copied, as they are created only by
2092  * an executing statement
2093  */
2094  return newstmt;
2095 }

Here is the caller graph for this function:

void Statement::execute ( class ApiInterface *  reentryObject,
apifPtr  reentryfptr,
int64_t  reentrypoint,
void *  reentrydata,
class Transaction *  transactionPtrarg,
const vector< string > &  parametersarg 
)

execute SQL statement

Parameters
reentryObjectobject to continue to after execution
reentryfptrfunction pointer to continue to
reentrypointentry point to continue to
reentrydataarbitrary data to pass to continuation
transactionPtrargassociated Transaction (NULL if none)
parametersargparameters to SQL statement

Definition at line 4783 of file Asts.cc.

References CMD_DELETE, CMD_INSERT, CMD_SELECT, CMD_UPDATE, parameters, queries, queryindex, reentry, Statement::reentry_s::reentrydata, Statement::reentry_s::reentryfptr, Statement::reentry_s::reentryObject, Statement::reentry_s::reentrypoint, ApiInterface::results, startQuery(), and transactionPtr.

Referenced by ApiInterface::execStatement(), and Pg::executeStatement().

4787 {
4788  reentry.reentryObject=reentryObject;
4789  reentry.reentryfptr=reentryfptr;
4790  reentry.reentrypoint=reentrypoint;
4791  reentry.reentrydata=reentrydata;
4792 
4793  reentryObject->results.cmdtype=queries[0].type;
4794 
4795  switch (reentryObject->results.cmdtype)
4796  {
4797  case CMD_SELECT:
4798  if (transactionPtrarg==NULL)
4799  {
4800  transactionPtr = new class Transaction(taPtr, schemaPtr->domainid);
4801  }
4802  else
4803  {
4804  transactionPtr = transactionPtrarg;
4805  }
4806 
4807  break;
4808 
4809  case CMD_INSERT:
4810  if (transactionPtrarg==NULL)
4811  {
4812  transactionPtr = new class Transaction(taPtr, schemaPtr->domainid);
4813  }
4814  else
4815  {
4816  transactionPtr = transactionPtrarg;
4817  }
4818 
4819  break;
4820 
4821  case CMD_UPDATE:
4822  if (transactionPtrarg==NULL)
4823  {
4824  transactionPtr = new class Transaction(taPtr, schemaPtr->domainid);
4825  }
4826  else
4827  {
4828  transactionPtr = transactionPtrarg;
4829  }
4830 
4831  break;
4832 
4833  case CMD_DELETE:
4834  if (transactionPtrarg==NULL)
4835  {
4836  transactionPtr = new class Transaction(taPtr, schemaPtr->domainid);
4837  }
4838  else
4839  {
4840  transactionPtr = transactionPtrarg;
4841  }
4842 
4843  break;
4844 
4845  default:
4846  transactionPtr = transactionPtrarg;
4847  }
4848 
4849  parameters = parametersarg;
4850  queryindex = queries.size()-1;
4851  startQuery();
4852 }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t Statement::getfieldid ( int64_t  tableid,
const string &  fieldName 
)

returns fieldid

Parameters
tableidtableid
fieldNamename of field
Returns
fieldid

Definition at line 2375 of file Asts.cc.

References Schema::fieldNameToId, and schemaPtr.

Referenced by resolveFieldNames(), and resolveTableFields2().

2376 {
2377  if (!schemaPtr->fieldNameToId.count(tableid))
2378  {
2379  return -1;
2380  }
2381 
2382  boost::unordered_map<string, int64_t> &ref =
2383  schemaPtr->fieldNameToId[tableid];
2384  boost::unordered_map<string, int64_t>::iterator it;
2385  it = ref.find(fieldName);
2386 
2387  if (it==ref.end())
2388  {
2389  return -1;
2390  }
2391 
2392  return ref[fieldName];
2393 }

Here is the caller graph for this function:

Statement & Statement::operator= ( const Statement &  orig)

Definition at line 2006 of file Asts.cc.

References cp().

2007 {
2008  cp(orig);
2009  return *this;
2010 }

Here is the call graph for this function:

void Statement::reenter ( int64_t  status)

return to calling function (Statement execution complete)

Parameters
status

Definition at line 5170 of file Asts.cc.

References NOCOMMAND, Transaction::pendingcmd, Transaction::pendingcmdid, reentry, Statement::reentry_s::reentrydata, Statement::reentry_s::reentryfptr, Statement::reentry_s::reentryObject, Statement::reentry_s::reentrypoint, ApiInterface::results, ApiInterface::statementPtr, and transactionPtr.

Referenced by abortQuery(), branchtotype(), and startQuery().

5171 {
5172  class ApiInterface *reentryObject=reentry.reentryObject;
5173  apifPtr reentryfptr=reentry.reentryfptr;
5174  int64_t reentrypoint=reentry.reentrypoint;
5175  void *reentrydata=reentry.reentrydata;
5176 
5177  if (transactionPtr != NULL)
5178  {
5179  transactionPtr->pendingcmd=NOCOMMAND;
5180  transactionPtr->pendingcmdid=0;
5181  }
5182 
5183  delete this;
5184  reentryObject->statementPtr=NULL;
5185  reentryObject->results.statementStatus=status;
5186  reentryObject->results.transactionPtr=transactionPtr;
5187  (*reentryObject.*reentryfptr)(reentrypoint, reentrydata);
5188 }

Here is the caller graph for this function:

bool Statement::resolveFieldNames ( class Ast *  myPosition)

field name resolution for resolveTableFields

Parameters
myPositionAst with field name as operand
Returns
success (true) or failure (false)

Definition at line 2283 of file Asts.cc.

References currentQuery, FROM_ABOVE, FROM_LEFT, FROM_RIGHT, getfieldid(), Ast::isoperator, Ast::leftchild, Ast::operand, OPERAND_FIELDID, OPERAND_IDENTIFIER, Ast::parent, Ast::rightchild, and Statement::query_s::tableid.

Referenced by resolveTableFields2().

2284 {
2285  direction_e direction = FROM_ABOVE;
2286  bool isbreakout=false;
2287 
2288  while (1)
2289  {
2290  if (myPosition->isoperator==false &&
2291  myPosition->operand[0]==OPERAND_IDENTIFIER)
2292  {
2293  // CONVERT
2294  string fname = myPosition->operand.substr(1, string::npos);
2295  int64_t fid = getfieldid(currentQuery->tableid, fname);
2296 
2297  if (fid==-1)
2298  {
2299  printf("%s %i tableid field not found %li %s\n", __FILE__,
2300  __LINE__, currentQuery->tableid, fname.c_str());
2301  return false;
2302  }
2303  else
2304  {
2305  myPosition->operand.assign(1 + sizeof(fid), char(0));
2306  myPosition->operand[0] = OPERAND_FIELDID;
2307  memcpy(&myPosition->operand[1], &fid, sizeof(fid));
2308  }
2309 
2310  direction=FROM_RIGHT;
2311  }
2312 
2313  switch (direction)
2314  {
2315  case FROM_ABOVE:
2316  if (myPosition->leftchild==NULL || myPosition==myPosition->leftchild)
2317  {
2318  direction=FROM_LEFT;
2319  }
2320  else
2321  {
2322  myPosition=myPosition->leftchild;
2323  // direction=FROM_ABOVE; already set
2324  }
2325 
2326  break;
2327 
2328  case FROM_LEFT:
2329  if (myPosition->rightchild==NULL)
2330  {
2331  direction=FROM_RIGHT;
2332  }
2333  else
2334  {
2335  myPosition=myPosition->rightchild;
2336  direction=FROM_ABOVE;
2337  }
2338 
2339  break;
2340 
2341  case FROM_RIGHT:
2342  if (myPosition->parent==NULL)
2343  {
2344  isbreakout=true;
2345  }
2346  else
2347  {
2348  if (myPosition==myPosition->parent->leftchild)
2349  {
2350  direction=FROM_LEFT;
2351  }
2352  else // i am parent's right child
2353  {
2354  direction=FROM_RIGHT;
2355  }
2356 
2357  myPosition=myPosition->parent;
2358  }
2359 
2360  break;
2361 
2362  default:
2363  printf("%s %i anomaly %i\n", __FILE__, __LINE__, direction);
2364  return false;
2365  }
2366 
2367  if (isbreakout==true)
2368  {
2369  return true;
2370  // break;
2371  }
2372  }
2373 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Statement::resolveTableFields ( )

resolves table and field names to integers

Returns
success (true) or failure (false)

Definition at line 2128 of file Asts.cc.

References CMD_DELETE, CMD_INSERT, CMD_SELECT, CMD_UPDATE, currentQuery, queries, resolveTableFields2(), and Statement::query_s::type.

Referenced by Pg::executeStatement(), and TransactionAgent::newstatement().

2129 {
2130  for (size_t n=0; n < queries.size(); n++)
2131  {
2132  currentQuery=&queries[n];
2133 
2134  switch (currentQuery->type)
2135  {
2136  case CMD_SELECT:
2137  break;
2138 
2139  case CMD_INSERT:
2140  break;
2141 
2142  case CMD_UPDATE:
2143  break;
2144 
2145  case CMD_DELETE:
2146  break;
2147 
2148  default: // noop, must be BEGIN, COMMIT, etc.
2149  return true;
2150  }
2151 
2152  if (resolveTableFields2()==false)
2153  {
2154  return false;
2155  }
2156  }
2157 
2158  return true;
2159 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Statement::resolveTableFields2 ( )

called by resolveTableFields recursively on each query then subquery to resolve table and field names to integers

Returns
success (true) or failure (false)

Definition at line 2161 of file Asts.cc.

References Statement::query_s::assignments, CMD_SELECT, CMD_UPDATE, currentQuery, Statement::query_s::fieldidAssignments, Table::fields, Statement::query_s::fromColumnids, Statement::query_s::fromColumns, getfieldid(), Statement::query_s::haswhere, OPERAND_AGGREGATE, OPERAND_FIELDID, OPERAND_IDENTIFIER, resolveFieldNames(), schemaPtr, Statement::query_s::searchCondition, Statement::query_s::table, Statement::query_s::tableid, Schema::tableNameToId, Schema::tables, and Statement::query_s::type.

Referenced by resolveTableFields().

2162 {
2163  // resolve tableid
2164  if (schemaPtr->tableNameToId.count(currentQuery->table))
2165  {
2166  currentQuery->tableid =
2167  schemaPtr->tableNameToId[currentQuery->table];
2168  }
2169  else
2170  {
2171  return false;
2172  }
2173 
2174  class Table &tableRef = *schemaPtr->tables[currentQuery->tableid];
2175 
2176  // resolve fieldids in select columns
2177  if (currentQuery->type==CMD_SELECT)
2178  {
2179  for (ssize_t n=currentQuery->fromColumns.size()-1; n >= 0; n--)
2180  {
2181  string &fromColumnRef = currentQuery->fromColumns[n];
2182 
2183  switch (fromColumnRef[0])
2184  {
2185  case '*':
2186  {
2187  for (size_t n=0;
2188  n < tableRef.fields.size();
2189  n++)
2190  {
2191  currentQuery->fromColumnids.push_back({OPERAND_FIELDID,
2192  (int64_t)n, tableRef.fields[n].name
2193  });
2194  }
2195  }
2196  break;
2197 
2198  case OPERAND_IDENTIFIER: // regular identifier
2199  {
2200  string fname = fromColumnRef.substr(1, string::npos);
2201  int64_t fid = getfieldid(currentQuery->tableid, fname);
2202 
2203  if (fid==-1)
2204  {
2205  printf("%s %i tableid field not found %li %s\n", __FILE__,
2206  __LINE__, currentQuery->tableid, fname.c_str());
2207  return false;
2208  }
2209  else
2210  {
2211  currentQuery->fromColumnids.push_back({OPERAND_FIELDID, fid,
2212  tableRef.fields[fid].name
2213  });
2214  }
2215  }
2216  break;
2217 
2218  case OPERAND_AGGREGATE: // aggregate
2219  {
2220  string fname = fromColumnRef.substr(2, string::npos);
2221  int64_t fid = getfieldid(currentQuery->tableid, fname);
2222 
2223  if (fid==-1)
2224  {
2225  printf("%s %i tableid field not found %li %s\n", __FILE__,
2226  __LINE__, currentQuery->tableid, fname.c_str());
2227  return false;
2228  }
2229  else
2230  {
2231  currentQuery->fromColumnids.push_back({fromColumnRef[1], fid,
2232  tableRef.fields[fid].name
2233  });
2234  }
2235  }
2236  break;
2237 
2238  default:
2239  printf("%s %i anomaly %c\n", __FILE__, __LINE__,
2240  fromColumnRef[0]);
2241  return false;
2242  }
2243  }
2244  }
2245  else if (currentQuery->type==CMD_UPDATE)
2246  {
2247  boost::unordered_map<string, class Ast *>::iterator it;
2248 
2249  for (it = currentQuery->assignments.begin();
2250  it != currentQuery->assignments.end(); it++)
2251  {
2252  int64_t fid = getfieldid(currentQuery->tableid, it->first);
2253 
2254  if (fid==-1)
2255  {
2256  printf("%s %i tableid field not found %li %s\n", __FILE__,
2257  __LINE__, currentQuery->tableid, it->first.c_str());
2258  return false;
2259  }
2260  else
2261  {
2262  currentQuery->fieldidAssignments[fid] = it->second;
2263  }
2264 
2265  if (resolveFieldNames(it->second)==false)
2266  {
2267  return false;
2268  }
2269  }
2270  }
2271 
2272  if (currentQuery->haswhere==true)
2273  {
2274  if (resolveFieldNames(currentQuery->searchCondition)==false)
2275  {
2276  return false;
2277  }
2278  }
2279 
2280  return true;
2281 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::searchExpression ( int64_t  entrypoint,
class Ast *  astNode 
)

perform search expression

return if evaluation is complete (true), or incomplete (false) if incomplete, caller should return as it means a background transaction call is taking place if the nextastnode is NULL, or it should execute the nextastnode, which is one of the children

Parameters
entrypointentrypoint in calling function to return to
astNodeAst to evaluate

Definition at line 4857 of file Asts.cc.

References branchtotype(), currentQuery, Ast::evaluate(), Ast::predicateResults, Statement::query_s::results, Statement::query_s::searchCondition, and Statement::results_s::searchResults.

Referenced by branchtotype(), Transaction::continueSqlPredicate(), Ast::evaluate(), Transaction::sqlPredicate(), and startQuery().

4858 {
4859  class Ast *nextAstNode=NULL;
4860 
4861  while (1)
4862  {
4863  if (astNode->evaluate(&nextAstNode, this)==true)
4864  {
4865  // node evaluated successfully
4866  if (nextAstNode==NULL) // rootnode evaluated, carry on with statement
4867  {
4868  switch (entrypoint)
4869  if (entrypoint==1)
4870  {
4871  case 1:
4872  currentQuery->results.searchResults =
4873  currentQuery->searchCondition->predicateResults;
4874  delete currentQuery->searchCondition;
4875  currentQuery->searchCondition=NULL;
4876  branchtotype();
4877  break;
4878 
4879  case 2:
4880  branchtotype();
4881  break;
4882 
4883  default:
4884  ;
4885  }
4886 
4887  return;
4888  }
4889 
4890  // non-rootnode evaluated, so set up for the next
4891  astNode=nextAstNode;
4892  }
4893  else
4894  {
4895  // node not evaluated successfully
4896  if (nextAstNode==NULL)
4897  {
4898  /* backgrounded query, will continue */
4899  return;
4900  }
4901 
4902  // evaluate a child
4903  astNode=nextAstNode;
4904  }
4905  }
4906 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Statement::stagedPredicate ( operatortypes_e  op,
int64_t  tableid,
string &  leftoperand,
string &  rightoperand,
vector< fieldValue_s > &  inValues,
const boost::unordered_map< uuRecord_s, stagedRow_s > &  stagedRows,
boost::unordered_map< uuRecord_s, returnRow_s > &  results 
)

perform search predicate query on results already gathered by this transaction. saves from having to do unnecessary message traffic with engines

Parameters
opoperation
tableidtbaleid
leftoperandleft operand of Ast
rightoperandright operand of Ast
inValuesfor IN (or NOT IN) predicate, these are the values
stagedRowsrows already gathered
resultsrows matched by predicate
Returns
true if rows matched, false if none

Definition at line 2395 of file Asts.cc.

References BOOL, fieldInput_u::boolean, CHAR, fieldInput_u::character, CHARX, compareFields(), Table::fields, FLOAT, fieldInput_u::floating, INT, fieldInput_u::integer, fieldValue_s::isnull, OPERAND_FIELDID, OPERATOR_BETWEEN, OPERATOR_EQ, OPERATOR_GT, OPERATOR_GTE, OPERATOR_IN, OPERATOR_ISNOTNULL, OPERATOR_ISNULL, OPERATOR_LT, OPERATOR_LTE, OPERATOR_NE, OPERATOR_NOTBETWEEN, OPERATOR_NOTIN, returnRow_s::row, schemaPtr, stagedRow2ReturnRow(), fieldValue_s::str, uuRecord_s::tableid, Schema::tables, Ast::toFloat(), Table::unmakerow(), fieldValue_s::value, and VARCHAR.

Referenced by Ast::evaluate().

2400 {
2401  bool equalhit=false;
2402 
2403  if (op != OPERATOR_IN && op != OPERATOR_NOTIN && op != OPERATOR_ISNULL &&
2404  op != OPERATOR_ISNOTNULL)
2405  {
2406  if (leftoperand[0] != OPERAND_FIELDID)
2407  {
2408  printf("%s %i left operand is not fieldid, it is '%c'\n",
2409  __FILE__, __LINE__, leftoperand[0]);
2410  return equalhit;
2411  }
2412  }
2413 
2414  int64_t fieldid;
2415  memcpy(&fieldid, &leftoperand[1], sizeof(fieldid));
2416 
2417  class Table &tableRef = *schemaPtr->tables[tableid];
2418  vector<fieldValue_s> fieldValues;
2419 
2420  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
2421 
2422  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
2423  {
2424  const uuRecord_s &uurRef = it->first;
2425 
2426  if (uurRef.tableid != tableid)
2427  {
2428  continue;
2429  }
2430 
2431  const stagedRow_s &stagedRowRef = it->second;
2432  returnRow_s returnRow;
2433  stagedRow2ReturnRow(stagedRowRef, returnRow);
2434 
2435  tableRef.unmakerow((string *)&returnRow.row, &fieldValues);
2436  fieldValue_s &lhs = fieldValues[fieldid];
2437 
2438  switch (tableRef.fields[fieldid].type)
2439  {
2440  case INT:
2441  {
2442  switch (op)
2443  {
2444  case OPERATOR_EQ:
2445  {
2446  // indexRef.getequal
2447  int64_t rhsval;
2448  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2449 
2450  if (lhs.value.integer==rhsval)
2451  {
2452  results[uurRef] = returnRow;
2453  equalhit=true;
2454  }
2455  }
2456  break;
2457 
2458  case OPERATOR_NE:
2459  {
2460  int64_t rhsval;
2461  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2462 
2463  if (lhs.value.integer!=rhsval)
2464  {
2465  results[uurRef] = returnRow;
2466  }
2467  }
2468  break;
2469 
2470  case OPERATOR_GT:
2471  {
2472  int64_t rhsval;
2473  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2474 
2475  if (lhs.value.integer>rhsval)
2476  {
2477  results[uurRef] = returnRow;
2478  }
2479  }
2480  break;
2481 
2482  case OPERATOR_LT:
2483  {
2484  int64_t rhsval;
2485  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2486 
2487  if (lhs.value.integer<rhsval)
2488  {
2489  results[uurRef] = returnRow;
2490  }
2491  }
2492  break;
2493 
2494  case OPERATOR_GTE:
2495  {
2496  int64_t rhsval;
2497  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2498 
2499  if (lhs.value.integer>=rhsval)
2500  {
2501  results[uurRef] = returnRow;
2502  }
2503  }
2504  break;
2505 
2506  case OPERATOR_LTE:
2507  {
2508  int64_t rhsval;
2509  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2510 
2511  if (lhs.value.integer<=rhsval)
2512  {
2513  results[uurRef] = returnRow;
2514  }
2515  }
2516  break;
2517 
2518  case OPERATOR_BETWEEN:
2519  {
2520  int64_t rhsval;
2521  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2522  int64_t rhsval2;
2523  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
2524  sizeof(rhsval2));
2525 
2526  if (lhs.value.integer >= rhsval && lhs.value.integer <= rhsval2)
2527  {
2528  results[uurRef] = returnRow;
2529  }
2530  }
2531  break;
2532 
2533  case OPERATOR_NOTBETWEEN:
2534  {
2535  int64_t rhsval;
2536  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2537  int64_t rhsval2;
2538  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
2539  sizeof(rhsval2));
2540 
2541  if (lhs.value.integer < rhsval || lhs.value.integer > rhsval2)
2542  {
2543  results[uurRef] = returnRow;
2544  }
2545  }
2546  break;
2547 
2548  case OPERATOR_IN:
2549  {
2550  int64_t fieldid;
2551  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
2552  vector<fieldValue_s> fieldValues;
2553  class Table &tableRef = *schemaPtr->tables[tableid];
2554  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
2555  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
2556 
2557  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
2558  {
2559  const uuRecord_s &uurRef = it->first;
2560  const stagedRow_s &sRowRef = it->second;
2561  returnRow_s rRow;
2562  stagedRow2ReturnRow(sRowRef, rRow);
2563  tableRef.unmakerow(&rRow.row, &fieldValues);
2564 
2565  for (size_t n=0; inValues.size(); n++)
2566  {
2567  if (compareFields(fieldtype, fieldValues[fieldid],
2568  inValues[n])==true)
2569  {
2570  results[uurRef] = rRow;
2571  }
2572  }
2573  }
2574  }
2575  break;
2576 
2577  case OPERATOR_NOTIN:
2578  {
2579  int64_t fieldid;
2580  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
2581  vector<fieldValue_s> fieldValues;
2582  class Table &tableRef = *schemaPtr->tables[tableid];
2583  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
2584  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
2585 
2586  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
2587  {
2588  const uuRecord_s &uurRef = it->first;
2589  const stagedRow_s &sRowRef = it->second;
2590  returnRow_s rRow;
2591  stagedRow2ReturnRow(sRowRef, rRow);
2592  tableRef.unmakerow(&rRow.row, &fieldValues);
2593  bool notin=true;
2594 
2595  for (size_t n=0; inValues.size(); n++)
2596  {
2597  if (compareFields(fieldtype, fieldValues[fieldid],
2598  inValues[n])==true)
2599  {
2600  notin=false;
2601  break;
2602  }
2603  }
2604 
2605  if (notin==true)
2606  {
2607  results[uurRef] = rRow;
2608  }
2609  }
2610  }
2611  break;
2612 
2613  case OPERATOR_ISNULL:
2614  {
2615  if (lhs.isnull==true)
2616  {
2617  results[uurRef] = returnRow;
2618  }
2619  }
2620  break;
2621 
2622  case OPERATOR_ISNOTNULL:
2623  {
2624  if (lhs.isnull==false)
2625  {
2626  results[uurRef] = returnRow;
2627  }
2628  }
2629  break;
2630 
2631  default:
2632  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
2633  return equalhit;
2634  }
2635  }
2636  break;
2637 
2638  case BOOL:
2639  {
2640  switch (op)
2641  {
2642  case OPERATOR_EQ:
2643  {
2644  // indexRef.getequal
2645  bool rhsval;
2646  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2647 
2648  if (lhs.value.boolean==rhsval)
2649  {
2650  results[uurRef] = returnRow;
2651  }
2652  }
2653  break;
2654 
2655  case OPERATOR_NE:
2656  {
2657  bool rhsval;
2658  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2659 
2660  if (lhs.value.boolean!=rhsval)
2661  {
2662  results[uurRef] = returnRow;
2663  }
2664  }
2665  break;
2666 
2667  case OPERATOR_GT:
2668  {
2669  bool rhsval;
2670  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2671 
2672  if (lhs.value.boolean>rhsval)
2673  {
2674  results[uurRef] = returnRow;
2675  }
2676  }
2677  break;
2678 
2679  case OPERATOR_LT:
2680  {
2681  bool rhsval;
2682  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2683 
2684  if (lhs.value.boolean<rhsval)
2685  {
2686  results[uurRef] = returnRow;
2687  }
2688  }
2689  break;
2690 
2691  case OPERATOR_GTE:
2692  {
2693  bool rhsval;
2694  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2695 
2696  if (lhs.value.boolean>=rhsval)
2697  {
2698  results[uurRef] = returnRow;
2699  }
2700  }
2701  break;
2702 
2703  case OPERATOR_LTE:
2704  {
2705  bool rhsval;
2706  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2707 
2708  if (lhs.value.boolean<=rhsval)
2709  {
2710  results[uurRef] = returnRow;
2711  }
2712  }
2713  break;
2714 
2715  case OPERATOR_BETWEEN:
2716  {
2717  bool rhsval;
2718  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2719  bool rhsval2;
2720  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
2721  sizeof(rhsval2));
2722 
2723  if (lhs.value.boolean >= rhsval && lhs.value.boolean <= rhsval2)
2724  {
2725  results[uurRef] = returnRow;
2726  }
2727  }
2728  break;
2729 
2730  case OPERATOR_NOTBETWEEN:
2731  {
2732  bool rhsval;
2733  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2734  bool rhsval2;
2735  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
2736  sizeof(rhsval2));
2737 
2738  if (lhs.value.boolean < rhsval || lhs.value.boolean > rhsval2)
2739  {
2740  results[uurRef] = returnRow;
2741  }
2742  }
2743  break;
2744 
2745  case OPERATOR_IN:
2746  {
2747  int64_t fieldid;
2748  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
2749  vector<fieldValue_s> fieldValues;
2750  class Table &tableRef = *schemaPtr->tables[tableid];
2751  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
2752  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
2753 
2754  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
2755  {
2756  const uuRecord_s &uurRef = it->first;
2757  const stagedRow_s &sRowRef = it->second;
2758  returnRow_s rRow;
2759  stagedRow2ReturnRow(sRowRef, rRow);
2760  tableRef.unmakerow(&rRow.row, &fieldValues);
2761 
2762  for (size_t n=0; inValues.size(); n++)
2763  {
2764  if (compareFields(fieldtype, fieldValues[fieldid],
2765  inValues[n])==true)
2766  {
2767  results[uurRef] = rRow;
2768  }
2769  }
2770  }
2771  }
2772  break;
2773 
2774  case OPERATOR_NOTIN:
2775  {
2776  int64_t fieldid;
2777  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
2778  vector<fieldValue_s> fieldValues;
2779  class Table &tableRef = *schemaPtr->tables[tableid];
2780  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
2781  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
2782 
2783  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
2784  {
2785  const uuRecord_s &uurRef = it->first;
2786  const stagedRow_s &sRowRef = it->second;
2787  returnRow_s rRow;
2788  stagedRow2ReturnRow(sRowRef, rRow);
2789  tableRef.unmakerow(&rRow.row, &fieldValues);
2790  bool notin=true;
2791 
2792  for (size_t n=0; inValues.size(); n++)
2793  {
2794  if (compareFields(fieldtype, fieldValues[fieldid],
2795  inValues[n])==true)
2796  {
2797  notin=false;
2798  break;
2799  }
2800  }
2801 
2802  if (notin==true)
2803  {
2804  results[uurRef] = rRow;
2805  }
2806  }
2807  }
2808  break;
2809 
2810  case OPERATOR_ISNULL:
2811  {
2812  if (lhs.isnull==true)
2813  {
2814  results[uurRef] = returnRow;
2815  }
2816  }
2817  break;
2818 
2819  case OPERATOR_ISNOTNULL:
2820  {
2821  if (lhs.isnull==false)
2822  {
2823  results[uurRef] = returnRow;
2824  }
2825  }
2826  break;
2827 
2828  default:
2829  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
2830  return equalhit;
2831  }
2832  }
2833  break;
2834 
2835  case FLOAT:
2836  {
2837  switch (op)
2838  {
2839  case OPERATOR_EQ:
2840  {
2841  // indexRef.getequal
2842  Ast::toFloat(rightoperand, rightoperand);
2843  long double rhsval;
2844  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2845 
2846  if (lhs.value.floating==rhsval)
2847  {
2848  results[uurRef] = returnRow;
2849  }
2850  }
2851  break;
2852 
2853  case OPERATOR_NE:
2854  {
2855  Ast::toFloat(rightoperand, rightoperand);
2856  long double rhsval;
2857  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2858 
2859  if (lhs.value.floating!=rhsval)
2860  {
2861  results[uurRef] = returnRow;
2862  }
2863  }
2864  break;
2865 
2866  case OPERATOR_GT:
2867  {
2868  Ast::toFloat(rightoperand, rightoperand);
2869  long double rhsval;
2870  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2871 
2872  if (lhs.value.floating>rhsval)
2873  {
2874  results[uurRef] = returnRow;
2875  }
2876  }
2877  break;
2878 
2879  case OPERATOR_LT:
2880  {
2881  Ast::toFloat(rightoperand, rightoperand);
2882  long double rhsval;
2883  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2884 
2885  if (lhs.value.floating<rhsval)
2886  {
2887  results[uurRef] = returnRow;
2888  }
2889  }
2890  break;
2891 
2892  case OPERATOR_GTE:
2893  {
2894  Ast::toFloat(rightoperand, rightoperand);
2895  long double rhsval;
2896  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2897 
2898  if (lhs.value.floating>=rhsval)
2899  {
2900  results[uurRef] = returnRow;
2901  }
2902  }
2903  break;
2904 
2905  case OPERATOR_LTE:
2906  {
2907  Ast::toFloat(rightoperand, rightoperand);
2908  long double rhsval;
2909  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2910 
2911  if (lhs.value.floating<=rhsval)
2912  {
2913  results[uurRef] = returnRow;
2914  }
2915  }
2916  break;
2917 
2918  case OPERATOR_BETWEEN:
2919  {
2920  long double rhsval;
2921  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2922  long double rhsval2;
2923  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
2924  sizeof(rhsval2));
2925 
2926  if (lhs.value.floating >= rhsval && lhs.value.floating <=
2927  rhsval2)
2928  {
2929  results[uurRef] = returnRow;
2930  }
2931  }
2932  break;
2933 
2934  case OPERATOR_NOTBETWEEN:
2935  {
2936  long double rhsval;
2937  memcpy(&rhsval, &rightoperand[1], sizeof(rhsval));
2938  long double rhsval2;
2939  memcpy(&rhsval2, &rightoperand[1+sizeof(rhsval)],
2940  sizeof(rhsval2));
2941 
2942  if (lhs.value.floating < rhsval || lhs.value.floating > rhsval2)
2943  {
2944  results[uurRef] = returnRow;
2945  }
2946  }
2947  break;
2948 
2949  case OPERATOR_IN:
2950  {
2951  int64_t fieldid;
2952  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
2953  vector<fieldValue_s> fieldValues;
2954  class Table &tableRef = *schemaPtr->tables[tableid];
2955  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
2956  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
2957 
2958  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
2959  {
2960  const uuRecord_s &uurRef = it->first;
2961  const stagedRow_s &sRowRef = it->second;
2962  returnRow_s rRow;
2963  stagedRow2ReturnRow(sRowRef, rRow);
2964  tableRef.unmakerow(&rRow.row, &fieldValues);
2965 
2966  for (size_t n=0; inValues.size(); n++)
2967  {
2968  if (compareFields(fieldtype, fieldValues[fieldid],
2969  inValues[n])==true)
2970  {
2971  results[uurRef] = rRow;
2972  }
2973  }
2974  }
2975  }
2976  break;
2977 
2978  case OPERATOR_NOTIN:
2979  {
2980  int64_t fieldid;
2981  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
2982  vector<fieldValue_s> fieldValues;
2983  class Table &tableRef = *schemaPtr->tables[tableid];
2984  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
2985  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
2986 
2987  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
2988  {
2989  const uuRecord_s &uurRef = it->first;
2990  const stagedRow_s &sRowRef = it->second;
2991  returnRow_s rRow;
2992  stagedRow2ReturnRow(sRowRef, rRow);
2993  tableRef.unmakerow(&rRow.row, &fieldValues);
2994  bool notin=true;
2995 
2996  for (size_t n=0; inValues.size(); n++)
2997  {
2998  if (compareFields(fieldtype, fieldValues[fieldid],
2999  inValues[n])==true)
3000  {
3001  notin=false;
3002  break;
3003  }
3004  }
3005 
3006  if (notin==true)
3007  {
3008  results[uurRef] = rRow;
3009  }
3010  }
3011  }
3012  break;
3013 
3014  case OPERATOR_ISNULL:
3015  {
3016  if (lhs.isnull==true)
3017  {
3018  results[uurRef] = returnRow;
3019  }
3020  }
3021  break;
3022 
3023  case OPERATOR_ISNOTNULL:
3024  {
3025  if (lhs.isnull==false)
3026  {
3027  results[uurRef] = returnRow;
3028  }
3029  }
3030  break;
3031 
3032  default:
3033  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
3034  return equalhit;
3035  }
3036  }
3037  break;
3038 
3039  case CHAR:
3040  {
3041  switch (op)
3042  {
3043  case OPERATOR_EQ:
3044  {
3045  // indexRef.getequal
3046  char rhsval=rightoperand[1];
3047 
3048  if (lhs.value.character==rhsval)
3049  {
3050  results[uurRef] = returnRow;
3051  }
3052  }
3053  break;
3054 
3055  case OPERATOR_NE:
3056  {
3057  char rhsval=rightoperand[1];
3058 
3059  if (lhs.value.character!=rhsval)
3060  {
3061  results[uurRef] = returnRow;
3062  }
3063  }
3064  break;
3065 
3066  case OPERATOR_GT:
3067  {
3068  char rhsval=rightoperand[1];
3069 
3070  if (lhs.value.character>rhsval)
3071  {
3072  results[uurRef] = returnRow;
3073  }
3074  }
3075  break;
3076 
3077  case OPERATOR_LT:
3078  {
3079  char rhsval=rightoperand[1];
3080 
3081  if (lhs.value.character<rhsval)
3082  {
3083  results[uurRef] = returnRow;
3084  }
3085  }
3086  break;
3087 
3088  case OPERATOR_GTE:
3089  {
3090  char rhsval=rightoperand[1];
3091 
3092  if (lhs.value.character>=rhsval)
3093  {
3094  results[uurRef] = returnRow;
3095  }
3096  }
3097  break;
3098 
3099  case OPERATOR_LTE:
3100  {
3101  char rhsval=rightoperand[1];
3102 
3103  if (lhs.value.character<=rhsval)
3104  {
3105  results[uurRef] = returnRow;
3106  }
3107  }
3108  break;
3109 
3110  case OPERATOR_BETWEEN:
3111  {
3112  char rhsval=rightoperand[1+sizeof(int64_t)];
3113  char rhsval2=rightoperand[1+sizeof(int64_t)+1];
3114 
3115  if (lhs.value.character >= rhsval && lhs.value.character <=
3116  rhsval2)
3117  {
3118  results[uurRef] = returnRow;
3119  }
3120  }
3121  break;
3122 
3123  case OPERATOR_NOTBETWEEN:
3124  {
3125  char rhsval=rightoperand[1+sizeof(int64_t)];
3126  char rhsval2=rightoperand[1+sizeof(int64_t)+1];
3127 
3128  if (lhs.value.character < rhsval || lhs.value.character >
3129  rhsval2)
3130  {
3131  results[uurRef] = returnRow;
3132  }
3133  }
3134  break;
3135 
3136  case OPERATOR_IN:
3137  {
3138  int64_t fieldid;
3139  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3140  vector<fieldValue_s> fieldValues;
3141  class Table &tableRef = *schemaPtr->tables[tableid];
3142  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3143  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
3144 
3145  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
3146  {
3147  const uuRecord_s &uurRef = it->first;
3148  const stagedRow_s &sRowRef = it->second;
3149  returnRow_s rRow;
3150  stagedRow2ReturnRow(sRowRef, rRow);
3151  tableRef.unmakerow(&rRow.row, &fieldValues);
3152 
3153  for (size_t n=0; inValues.size(); n++)
3154  {
3155  if (compareFields(fieldtype, fieldValues[fieldid],
3156  inValues[n])==true)
3157  {
3158  results[uurRef] = rRow;
3159  }
3160  }
3161  }
3162  }
3163  break;
3164 
3165  case OPERATOR_NOTIN:
3166  {
3167  int64_t fieldid;
3168  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3169  vector<fieldValue_s> fieldValues;
3170  class Table &tableRef = *schemaPtr->tables[tableid];
3171  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3172  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
3173 
3174  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
3175  {
3176  const uuRecord_s &uurRef = it->first;
3177  const stagedRow_s &sRowRef = it->second;
3178  returnRow_s rRow;
3179  stagedRow2ReturnRow(sRowRef, rRow);
3180  tableRef.unmakerow(&rRow.row, &fieldValues);
3181  bool notin=true;
3182 
3183  for (size_t n=0; inValues.size(); n++)
3184  {
3185  if (compareFields(fieldtype, fieldValues[fieldid],
3186  inValues[n])==true)
3187  {
3188  notin=false;
3189  break;
3190  }
3191  }
3192 
3193  if (notin==true)
3194  {
3195  results[uurRef] = rRow;
3196  }
3197  }
3198  }
3199  break;
3200 
3201  case OPERATOR_ISNULL:
3202  {
3203  if (lhs.isnull==true)
3204  {
3205  results[uurRef] = returnRow;
3206  }
3207  }
3208  break;
3209 
3210  case OPERATOR_ISNOTNULL:
3211  {
3212  if (lhs.isnull==false)
3213  {
3214  results[uurRef] = returnRow;
3215  }
3216  }
3217  break;
3218 
3219  default:
3220  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
3221  return equalhit;
3222  }
3223  }
3224  break;
3225 
3226  case CHARX:
3227  {
3228  switch (op)
3229  {
3230  case OPERATOR_EQ:
3231  {
3232  // indexRef.getequal
3233  string rhsval=rightoperand.substr(1, string::npos);
3234 
3235  if (!lhs.str.compare(rhsval))
3236  {
3237  results[uurRef] = returnRow;
3238  }
3239  }
3240  break;
3241 
3242  case OPERATOR_NE:
3243  {
3244  string rhsval=rightoperand.substr(1, string::npos);
3245 
3246  if (lhs.str.compare(rhsval))
3247  {
3248  results[uurRef] = returnRow;
3249  }
3250  }
3251  break;
3252 
3253  case OPERATOR_IN:
3254  {
3255  int64_t fieldid;
3256  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3257  vector<fieldValue_s> fieldValues;
3258  class Table &tableRef = *schemaPtr->tables[tableid];
3259  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3260  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
3261 
3262  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
3263  {
3264  const uuRecord_s &uurRef = it->first;
3265  const stagedRow_s &sRowRef = it->second;
3266  returnRow_s rRow;
3267  stagedRow2ReturnRow(sRowRef, rRow);
3268  tableRef.unmakerow(&rRow.row, &fieldValues);
3269 
3270  for (size_t n=0; inValues.size(); n++)
3271  {
3272  if (compareFields(fieldtype, fieldValues[fieldid],
3273  inValues[n])==true)
3274  {
3275  results[uurRef] = rRow;
3276  }
3277  }
3278  }
3279  }
3280  break;
3281 
3282  case OPERATOR_NOTIN:
3283  {
3284  int64_t fieldid;
3285  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3286  vector<fieldValue_s> fieldValues;
3287  class Table &tableRef = *schemaPtr->tables[tableid];
3288  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3289  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
3290 
3291  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
3292  {
3293  const uuRecord_s &uurRef = it->first;
3294  const stagedRow_s &sRowRef = it->second;
3295  returnRow_s rRow;
3296  stagedRow2ReturnRow(sRowRef, rRow);
3297  tableRef.unmakerow(&rRow.row, &fieldValues);
3298  bool notin=true;
3299 
3300  for (size_t n=0; inValues.size(); n++)
3301  {
3302  if (compareFields(fieldtype, fieldValues[fieldid],
3303  inValues[n])==true)
3304  {
3305  notin=false;
3306  break;
3307  }
3308  }
3309 
3310  if (notin==true)
3311  {
3312  results[uurRef] = rRow;
3313  }
3314  }
3315  }
3316  break;
3317 
3318  case OPERATOR_ISNULL:
3319  {
3320  if (lhs.isnull==true)
3321  {
3322  results[uurRef] = returnRow;
3323  }
3324  }
3325  break;
3326 
3327  case OPERATOR_ISNOTNULL:
3328  {
3329  if (lhs.isnull==false)
3330  {
3331  results[uurRef] = returnRow;
3332  }
3333  }
3334  break;
3335 
3336  default:
3337  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
3338  return equalhit;
3339  }
3340  }
3341  break;
3342 
3343  case VARCHAR:
3344  {
3345  switch (op)
3346  {
3347  case OPERATOR_EQ:
3348  {
3349  // indexRef.getequal
3350  string rhsval=rightoperand.substr(1, string::npos);
3351 
3352  if (!lhs.str.compare(rhsval))
3353  {
3354  results[uurRef] = returnRow;
3355  }
3356  }
3357  break;
3358 
3359  case OPERATOR_NE:
3360  {
3361  string rhsval=rightoperand.substr(1, string::npos);
3362 
3363  if (lhs.str.compare(rhsval))
3364  {
3365  results[uurRef] = returnRow;
3366  }
3367  }
3368  break;
3369 
3370  case OPERATOR_IN:
3371  {
3372  int64_t fieldid;
3373  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3374  vector<fieldValue_s> fieldValues;
3375  class Table &tableRef = *schemaPtr->tables[tableid];
3376  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3377  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
3378 
3379  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
3380  {
3381  const uuRecord_s &uurRef = it->first;
3382  const stagedRow_s &sRowRef = it->second;
3383  returnRow_s rRow;
3384  stagedRow2ReturnRow(sRowRef, rRow);
3385  tableRef.unmakerow(&rRow.row, &fieldValues);
3386 
3387  for (size_t n=0; inValues.size(); n++)
3388  {
3389  if (compareFields(fieldtype, fieldValues[fieldid],
3390  inValues[n])==true)
3391  {
3392  results[uurRef] = rRow;
3393  }
3394  }
3395  }
3396  }
3397  break;
3398 
3399  case OPERATOR_NOTIN:
3400  {
3401  int64_t fieldid;
3402  memcpy(&fieldid, &rightoperand[1], sizeof(fieldid));
3403  vector<fieldValue_s> fieldValues;
3404  class Table &tableRef = *schemaPtr->tables[tableid];
3405  fieldtype_e fieldtype = tableRef.fields[fieldid].type;
3406  boost::unordered_map<uuRecord_s, stagedRow_s>::const_iterator it;
3407 
3408  for (it = stagedRows.begin(); it != stagedRows.end(); it++)
3409  {
3410  const uuRecord_s &uurRef = it->first;
3411  const stagedRow_s &sRowRef = it->second;
3412  returnRow_s rRow;
3413  stagedRow2ReturnRow(sRowRef, rRow);
3414  tableRef.unmakerow(&rRow.row, &fieldValues);
3415  bool notin=true;
3416 
3417  for (size_t n=0; inValues.size(); n++)
3418  {
3419  if (compareFields(fieldtype, fieldValues[fieldid],
3420  inValues[n])==true)
3421  {
3422  notin=false;
3423  break;
3424  }
3425  }
3426 
3427  if (notin==true)
3428  {
3429  results[uurRef] = rRow;
3430  }
3431  }
3432  }
3433  break;
3434 
3435  case OPERATOR_ISNULL:
3436  {
3437  if (lhs.isnull==true)
3438  {
3439  results[uurRef] = returnRow;
3440  }
3441  }
3442  break;
3443 
3444  case OPERATOR_ISNOTNULL:
3445  {
3446  if (lhs.isnull==false)
3447  {
3448  results[uurRef] = returnRow;
3449  }
3450  }
3451  break;
3452 
3453  default:
3454  printf("%s %i anomaly %i\n", __FILE__, __LINE__, op);
3455  return equalhit;
3456  }
3457  }
3458  break;
3459 
3460  default:
3461  printf("%s %i anomaly %i\n", __FILE__, __LINE__,
3462  tableRef.fields[fieldid].type);
3463  return equalhit;
3464  }
3465  }
3466 
3467  return equalhit;
3468 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::startQuery ( )

begin query execution

Definition at line 5522 of file Asts.cc.

References branchtotype(), CMD_BEGIN, CMD_COMMIT, CMD_DELETE, CMD_INSERT, CMD_ROLLBACK, CMD_SELECT, CMD_UPDATE, currentQuery, Table::fields, Statement::query_s::fromColumnids, Statement::query_s::haswhere, returnRow_s::locktype, Statement::results_s::newrow, Statement::results_s::newrowuur, returnRow_s::previoussubtransactionid, queries, queryindex, reenter(), reentry, Statement::reentry_s::reentryObject, Statement::query_s::results, ApiInterface::results, returnRow_s::row, uuRecord_s::rowid, returnRow_s::rowid, schemaPtr, Statement::query_s::searchCondition, searchExpression(), Statement::results_s::searchResults, Statement::results_s::selectResults, STATUS_OK, Statement::query_s::tableid, Schema::tables, Statement::query_s::type, and WRITELOCK.

Referenced by branchtotype(), continueDelete(), continueInsert(), continueSelect(), continueUpdate(), and execute().

5523 {
5524  if (queryindex >= 0)
5525  {
5526  currentQuery = &queries[queryindex--];
5527 
5528  if (currentQuery->haswhere==true)
5529  {
5530  searchExpression(1, currentQuery->searchCondition);
5531  }
5532  else
5533  {
5534  branchtotype();
5535  }
5536  }
5537  else
5538  {
5539  // reenter
5540  /* put the final query results somewhere, like staged rows,
5541  * locking every row in every query, then put the results
5542  * somewhere the user can find them */
5543  switch (currentQuery->type)
5544  {
5545  case CMD_SELECT:
5546  {
5547  reentry.reentryObject->results.cmdtype = CMD_SELECT;
5548  reentry.reentryObject->results.statementStatus = STATUS_OK;
5549  reentry.reentryObject->results.selectResults =
5550  currentQuery->results.selectResults;
5551  class Table &tableRef = *schemaPtr->tables[currentQuery->tableid];
5552 
5553  for (size_t n=0; n < currentQuery->fromColumnids.size(); n++)
5554  {
5555  reentry.reentryObject->results.selectFields.push_back(
5556  {tableRef.fields[currentQuery->fromColumnids[n].fieldid].type, currentQuery->fromColumnids[n].name});
5557  }
5558  }
5559  break;
5560 
5561  case CMD_INSERT:
5562  {
5563  reentry.reentryObject->results.cmdtype = CMD_INSERT;
5564  reentry.reentryObject->results.statementStatus = STATUS_OK;
5565  returnRow_s returnRow;
5566  returnRow.rowid = currentQuery->results.newrowuur.rowid;
5567  returnRow.previoussubtransactionid = 0;
5568  returnRow.locktype = WRITELOCK;
5569  returnRow.row = currentQuery->results.newrow;
5570  reentry.reentryObject->results.statementResults[currentQuery->results.newrowuur] =
5571  returnRow;
5572  }
5573  break;
5574 
5575  case CMD_UPDATE:
5576  reentry.reentryObject->results.cmdtype = CMD_UPDATE;
5577  reentry.reentryObject->results.statementStatus = STATUS_OK;
5578  reentry.reentryObject->results.statementResults =
5579  currentQuery->results.searchResults;
5580  break;
5581 
5582  case CMD_DELETE:
5583  reentry.reentryObject->results.cmdtype = CMD_DELETE;
5584  reentry.reentryObject->results.statementStatus = STATUS_OK;
5585  reentry.reentryObject->results.statementResults =
5586  currentQuery->results.searchResults;
5587  break;
5588 
5589  case CMD_BEGIN:
5590  reentry.reentryObject->results.cmdtype = CMD_BEGIN;
5591  reentry.reentryObject->results.statementStatus = STATUS_OK;
5592  break;
5593 
5594  case CMD_COMMIT:
5595  reentry.reentryObject->results.cmdtype = CMD_COMMIT;
5596  reentry.reentryObject->results.statementStatus = STATUS_OK;
5597  break;
5598 
5599  case CMD_ROLLBACK:
5600  reentry.reentryObject->results.cmdtype = CMD_ROLLBACK;
5601  reentry.reentryObject->results.statementStatus = STATUS_OK;
5602  break;
5603 
5604  default:
5605  printf("%s %i anomaly %i\n", __FILE__, __LINE__, currentQuery->type);
5606  return;
5607  }
5608 
5609  reenter(STATUS_OK);
5610  }
5611 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Statement::subqueryExists ( class Ast *  astnode)

EXISTS subquery.

Parameters
astnode

Definition at line 5771 of file Asts.cc.

References Ast::operand, OPERAND_BOOLEAN, and queries.

Referenced by Ast::evaluate().

5772 {
5773  int64_t queryinstance;
5774  memcpy(&queryinstance, &astnode->operand[1], sizeof(queryinstance));
5775 
5776  astnode->operand.resize(OPERAND_BOOLEAN, 2);
5777 
5778  if (queries[queryinstance].results.selectResults.size())
5779  {
5780  astnode->operand[1]='t';
5781  }
5782  else
5783  {
5784  astnode->operand[1]='f';
5785  }
5786 }

Here is the caller graph for this function:

void Statement::subqueryIn ( class Ast *  astnode)

subquery returns list of values for IN predicate

Parameters
astnode

Definition at line 5788 of file Asts.cc.

References Statement::results_s::inValues, Ast::operand, queries, Statement::query_s::results, and Statement::results_s::selectResults.

Referenced by Ast::evaluate().

5789 {
5790  int64_t queryinstance;
5791  memcpy(&queryinstance, &astnode->operand[1], sizeof(queryinstance));
5792  query_s &queryRef = queries[queryinstance];
5793 
5794  boost::unordered_map< uuRecord_s, vector<fieldValue_s> >::iterator it;
5795 
5796  for (it = queryRef.results.selectResults.begin();
5797  it != queryRef.results.selectResults.end(); it++)
5798  {
5799  queryRef.results.inValues.push_back(it->second[0]);
5800  }
5801 }

Here is the caller graph for this function:

void Statement::subqueryScalar ( class Ast *  astnode)

subquery that returns a scalar

Parameters
astnode

Definition at line 5613 of file Asts.cc.

References BOOL, CHAR, CHARX, FLOAT, INT, Ast::operand, OPERAND_BOOLEAN, OPERAND_FLOAT, OPERAND_INTEGER, OPERAND_NULL, OPERAND_STRING, OPERAND_SUBQUERY, queries, Statement::query_s::results, schemaPtr, Statement::results_s::selectResults, Statement::query_s::tableid, Schema::tables, UINT, and VARCHAR.

Referenced by Ast::evaluate(), and Ast::normalizeSetAssignmentOperand().

5614 {
5615  if (astnode->operand[0] != OPERAND_SUBQUERY)
5616  {
5617  return;
5618  }
5619 
5620  int64_t queryinstance;
5621  memcpy(&queryinstance, &astnode->operand[1], sizeof(queryinstance));
5622 
5623  query_s &queryRef = queries[queryinstance];
5624  boost::unordered_map< uuRecord_s, vector<fieldValue_s> > &selectResultsRef =
5625  queryRef.results.selectResults;
5626 
5627  switch (selectResultsRef.size())
5628  {
5629  case 0:
5630  astnode->operand.assign(1, OPERAND_NULL);
5631  break;
5632 
5633  case 1:
5634  {
5635  boost::unordered_map< uuRecord_s,
5636  vector<fieldValue_s> >::const_iterator it;
5637  it = selectResultsRef.begin();
5638  const vector<fieldValue_s> &fieldValuesRef = it->second;
5639 
5640  if (fieldValuesRef.size()==1)
5641  {
5642  // get the field type table.fields[0].type fieldtype_e
5643  switch (schemaPtr->tables[queryRef.tableid]->fields[0].type)
5644  {
5645  case INT:
5646  astnode->operand.resize(1+sizeof(int64_t), (char)0);
5647  astnode->operand[0] = OPERAND_INTEGER;
5648  memcpy(&astnode->operand[1], &fieldValuesRef[0].value.integer,
5649  sizeof(int64_t));
5650  break;
5651 
5652  case UINT:
5653  astnode->operand.resize(1+sizeof(int64_t), (char)0);
5654  astnode->operand[0] = OPERAND_INTEGER;
5655  memcpy(&astnode->operand[1], &fieldValuesRef[0].value.uinteger,
5656  sizeof(int64_t));
5657  break;
5658 
5659  case BOOL:
5660  astnode->operand.resize(2, OPERAND_BOOLEAN);
5661 
5662  if (fieldValuesRef[0].value.boolean==true)
5663  {
5664  astnode->operand[1]='t';
5665  }
5666  else
5667  {
5668  astnode->operand[1]='f';
5669  }
5670 
5671  break;
5672 
5673  case FLOAT:
5674  astnode->operand.resize(1+sizeof(long double), (char)0);
5675  astnode->operand[0] = OPERAND_FLOAT;
5676  memcpy(&astnode->operand[1], &fieldValuesRef[0].value.floating,
5677  sizeof(int64_t));
5678  break;
5679 
5680  case CHAR:
5681  astnode->operand.resize(1+sizeof(char), (char)0);
5682  astnode->operand[0] = OPERAND_STRING;
5683  astnode->operand[1] = fieldValuesRef[0].value.character;
5684  break;
5685 
5686  case CHARX:
5687  astnode->operand.assign(1, OPERAND_STRING);
5688  astnode->operand.append(fieldValuesRef[0].str);
5689  break;
5690 
5691  case VARCHAR:
5692  astnode->operand.assign(1, OPERAND_STRING);
5693  astnode->operand.append(fieldValuesRef[0].str);
5694  break;
5695 
5696  default:
5697  printf("%s %i anomaly %i\n", __FILE__, __LINE__,
5698  schemaPtr->tables[queryRef.tableid]->fields[0].type);
5699  }
5700 
5701  return;
5702  }
5703  else
5704  {
5705  printf("%s %i too many columns in scalar subquery %lu\n", __FILE__,
5706  __LINE__, fieldValuesRef.size());
5707  }
5708  }
5709  break;
5710 
5711  default:
5712  printf("%s %i too many returned rows in scalar subquery %lu\n", __FILE__,
5713  __LINE__, selectResultsRef.size());
5714  }
5715 }

Here is the caller graph for this function:

void Statement::subqueryUnique ( class Ast *  astnode)

UNIQUE type of subquery.

Parameters
astnode

Definition at line 5717 of file Asts.cc.

References compareFields(), Table::fields, Statement::query_s::fromColumnids, Ast::operand, OPERAND_BOOLEAN, queries, Statement::query_s::results, schemaPtr, Statement::results_s::selectResults, Statement::query_s::tableid, and Schema::tables.

Referenced by Ast::evaluate().

5718 {
5719  int64_t queryinstance;
5720  memcpy(&queryinstance, &astnode->operand[1], sizeof(queryinstance));
5721  query_s &queryRef = queries[queryinstance];
5722  size_t numfields = queryRef.fromColumnids.size();
5723  class Table &tableRef = *schemaPtr->tables[queryRef.tableid];
5724 
5725  boost::unordered_map< uuRecord_s, vector<fieldValue_s> >::iterator it;
5726  boost::unordered_map< uuRecord_s, vector<fieldValue_s> >::iterator it2;
5727 
5728  for (it = queryRef.results.selectResults.begin();
5729  it != queryRef.results.selectResults.end(); it++)
5730  {
5731  const uuRecord_s &uurRef1 = it->first;
5732  const vector<fieldValue_s> &fieldValues = it->second;
5733 
5734  for (it2 = queryRef.results.selectResults.begin();
5735  it2 != queryRef.results.selectResults.end(); it++)
5736  {
5737  const uuRecord_s &uurRef2 = it2->first;
5738  const vector<fieldValue_s> &fieldValues2 = it->second;
5739 
5740  if (uurRef1==uurRef2)
5741  {
5742  continue;
5743  }
5744 
5745  bool ismatch=true;
5746 
5747  for (size_t n=0; n < numfields; n++)
5748  {
5749  if (compareFields(
5750  tableRef.fields[queryRef.fromColumnids[n].fieldid].type,
5751  fieldValues[n], fieldValues2[n])==false)
5752  {
5753  ismatch=false;
5754  break;
5755  }
5756  }
5757 
5758  if (ismatch==true)
5759  {
5760  astnode->operand.resize(OPERAND_BOOLEAN, 2);
5761  astnode->operand[1]='f';
5762  return;
5763  }
5764  }
5765  }
5766 
5767  astnode->operand.resize(OPERAND_BOOLEAN, 2);
5768  astnode->operand[1] = 't';
5769 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

query_s* Statement::currentQuery

Definition at line 468 of file Asts.h.

Referenced by branchtotype(), continueDelete(), continueSelect(), Transaction::continueSqlInsert(), Transaction::continueSqlReplace(), continueUpdate(), cp(), Ast::evaluate(), Ast::normalizeSetAssignmentOperand(), resolveFieldNames(), resolveTableFields(), resolveTableFields2(), searchExpression(), and startQuery().

std::vector<std::string> Statement::parameters

Definition at line 471 of file Asts.h.

Referenced by cp(), Ast::evaluate(), execute(), and Ast::normalizeSetAssignmentOperand().

std::vector<query_s> Statement::queries

Definition at line 470 of file Asts.h.

Referenced by Larxer::consumeSubquery(), Pg::cont(), cp(), Larxer::eatstack(), ApiInterface::execStatement(), execute(), Pg::executeStatement(), ApiInterface::getStoredProcedureArgs(), resolveTableFields(), startQuery(), subqueryExists(), subqueryIn(), subqueryScalar(), subqueryUnique(), and ~Statement().

ssize_t Statement::queryindex

Definition at line 473 of file Asts.h.

Referenced by cp(), execute(), and startQuery().

reentry_s Statement::reentry

Definition at line 466 of file Asts.h.

Referenced by branchtotype(), cp(), execute(), reenter(), startQuery(), and Statement().

class Schema* Statement::schemaPtr

Definition at line 465 of file Asts.h.

Referenced by andPredicate(), branchtotype(), continueSelect(), continueUpdate(), cp(), Ast::evaluate(), getfieldid(), Ast::normalizeSetAssignmentOperand(), resolveTableFields2(), stagedPredicate(), startQuery(), subqueryScalar(), and subqueryUnique().

class TransactionAgent* Statement::taPtr

Definition at line 464 of file Asts.h.

Referenced by branchtotype(), and cp().

class Transaction* Statement::transactionPtr

Definition at line 467 of file Asts.h.

Referenced by branchtotype(), continueDelete(), continueSelect(), continueUpdate(), cp(), Ast::evaluate(), execute(), and reenter().

The documentation for this class was generated from the following files: