// paramName must be passed in WITHOUT leading '$' (ERRORPARAM_BEGINMARK).
// paramName returns stripped of any internal '~' (ERRORPARAM_TYPESEP) and the
// chars either preceding it or following it, if paramName is at all valid.
// E.g., "0~string0" returns as "0" if positional but "string0" if named;
// "int0~1" returns as "1" if pos but "int0" if named;
// "2" returns as "2" either way;
// "b" returns as "b" either way (if pos, function result is -1, invalid);
// "intx~y" returns as "y" if pos (and function result is -1, invalid)
// but "intx~y" if named (with a successful result, and the ComDiagsMsg.C
// caller will reject it as not matching a string table lookup and then
// display the entire bogus name).
// Function returns -1 for invalid paramName,
// 0 for valid NAMED_PARAM,
// n>=0 for valid POSITIONAL_PARAM (n = the position, 0th, 1st, 2nd, ...)
//
// Why do we need to do this? Well, we have two kinds of messages --
// ComDiagsMsg.C ComCondition ones with named params, and
// ErrorMessage.C ErrorMessage ones with positional.
// The positional params need to have position numbers so that messages can
// be translated (I18N of text often requires reordering params).
// Tagging each param with both name and position info means that the same
// msg code can be used from anywhere (either ComDiags or E'Msg),
// i.e. we can share messages and not have a confusing welter of nearly
// identical ones.
//
Lng32 FixupMessageParam(NAWchar *paramName, MsgParamType paramType)
{
ComASSERT(paramName);
if (!*paramName) return -1; // invalid (empty) paramName
NAWchar *p;
NAWchar* sep = NAWstrchr(paramName, ERRORPARAM_TYPESEP);
NABoolean begend = sep ? (sep == paramName || sep[1] == NAWchar('\0')) : FALSE;
switch (paramType)
{
case NAMED_PARAM:
if (begend) return 0; // "~x" and "9~" `legal' names
if (sep)
if (isdigit(*paramName))
NAWstrcpy(paramName, ++sep); // "9~x" -> "x"
else if (isdigit(sep[1]))
*sep = NAWchar('\0'); // "x~9" -> "x"
//else {} // "x~y" `legal'
return 0; // (Dubious legal names will be
// flagged by our caller.)
case POSITIONAL_PARAM:
if (begend) return -1; // "~x" and "9~" invalid nums
if (!isdigit(*paramName))
if (!sep)
return -1; // "x" invalid num
else
NAWstrcpy(paramName, ++sep); // "x~9" -> "9"
else
if (sep)
*sep = NAWchar('\0'); // "9~x" -> "9"
//else {} // "9" valid
for (p=paramName; *p; p++)
if (!isdigit(*p))
return -1; // "9x" invalid num
Lng32 pos;
NAWsscanf(paramName, WIDE_("%d"), &pos);
return pos;
default:
return -1; // invalid (unknown paramType)
}
} // FixupMessageParam
// -----------------------------------------------------------------------
// Translate ANSI SQL names from Default ANSI SQL Name character set
// to UCS-2 encoding values. The contents of the outWcs parameter is
// clear and set to the newly computed UCS2 string
// -----------------------------------------------------------------------
void CmAnsiNameToUCS2(const NAString &inMbs, NAWString &outWcs)
{
outWcs.remove(0); // set to an empty string
if (inMbs.length() <= 0)
{
return;
}
NAWString * pTargetNAWString =
charToUnicode ( (Lng32)ComGetNameInterfaceCharSet() // in - Lng32 strCharSet
, inMbs.data() // in - const char * str
, (Int32)inMbs.length() // in - Int32 len
, (NAMemory *)STMTHEAP // in - NAMemory * h
);
ComASSERT(pTargetNAWString != NULL AND pTargetNAWString->length() > 0 AND
pTargetNAWString->length() <= ComMAX_ANSI_IDENTIFIER_INTERNAL_LEN/*in NAWchars*/);
outWcs.append(pTargetNAWString->data(), pTargetNAWString->length());
delete pTargetNAWString;
}
void
ElemDDLConstraintUnique::setColumnRefList(ElemDDLNode * pColumnRefList)
{
setChild(INDEX_COLUMN_NAME_LIST, pColumnRefList);
if (getColumnRefList())
{
//
// Copies information about the key column list to keyColumnArray_
// so the user can access the information easier. (Assumes that
// keyColumnArray_ is still empty.)
//
for (CollIndex i = 0; i < getColumnRefList()->entries(); i++)
{
ComASSERT((*getColumnRefList())[i] AND
(*getColumnRefList())[i]->castToElemDDLColRef());
keyColumnArray_.insert((*getColumnRefList())[i]->castToElemDDLColRef());
}
}
} // ElemDDLConstraintUnique::setColumnRefList()
// method for building text
//virtual
NAString ElemDDLFileAttrMaxSize::getSyntax() const
{
NAString syntax = "MAXSIZE ";
if (TRUE == isUnbounded_)
{
syntax += "UNBOUNDED";
}
else
{
#pragma nowarn(1506) // warning elimination
syntax += LongToNAString(maxSize_);
#pragma warn(1506) // warning elimination
syntax += " ";
switch(maxSizeUnit_)
{
case COM_BYTES:
syntax += "";
break;
case COM_KBYTES:
syntax += "K";
break;
case COM_MBYTES:
syntax += "M";
break;
case COM_GBYTES:
syntax += "G";
break;
default:
ComASSERT(FALSE);
break;
}
}
return syntax;
} // getSyntax
ElemDDLPartitionByColumnList::ElemDDLPartitionByColumnList(
ElemDDLNode * partitionKeyColumnList,
CollHeap * heap)
: ElemDDLPartitionByOpt(ELM_PARTITION_BY_COLUMN_LIST_ELEM),
partitionKeyColumnArray_(heap)
{
setChild(INDEX_PARTITION_KEY_COLUMN_LIST, partitionKeyColumnList);
//
// copies pointers to parse nodes representing
// column names (appearing in a partition by option)
// to partitionKeyColumnArray_ so the user can access
// this information easier.
//
ComASSERT(partitionKeyColumnList NEQ NULL);
for (CollIndex i = 0; i < partitionKeyColumnList->entries(); i++)
{
partitionKeyColumnArray_.insert((*partitionKeyColumnList)[i]->
castToElemDDLColRef());
}
}
// ComResWords::wordCompare() ===========================================
// comparison function for reserved word Table binary search
// returns: negative if val1 < val2 (table entry)
// zero if val1 == val2
// positive if val1 > val2
// =====================================================================
//
Int32 ComResWords::wordCompare(const void *val1, const void *val2)
{
// Cast the (void *) pointers to the (ComResWord *) which they must
// be.
//
ComResWord *val = (ComResWord *)val1;
ComResWord *entry = (ComResWord *)val2;
// If either entry is NULL or has a NULL word, return 0 (equal).
//
ComASSERT(val && val->getResWord() && entry && entry->getResWord());
// case-sensitive comparison
// (all words are uppercase)
//
Int32 len1 = str_len(val->getResWord());
Int32 len2 = str_len(entry->getResWord());
Int32 maxlen = (len1 > len2) ? len1 : len2;
return str_cmp(val->getResWord(), entry->getResWord(), maxlen);
}
NABoolean NAType::createSQLLiteral(const char * buf,
NAString *&stringLiteral,
NABoolean &isNull,
CollHeap *h) const
{
// the base class can handle the case of a NULL value and
// generate a NULL value, otherwise let the derived class
// generate a literal
if (supportsSQLnull())
{
Int32 nullValue = 0;
switch (getSQLnullHdrSize())
{
case 2:
{
Int16 tmp = *((Int16*) buf);
nullValue = tmp;
}
break;
default:
ComASSERT(FALSE);
}
if (nullValue)
{
stringLiteral = new(h) NAString("NULL", h);
isNull = TRUE;
return TRUE;
}
}
isNull = FALSE;
return FALSE;
}
ExprNode *
ElemDDLConstraint::getChild(Lng32 index)
{
ComASSERT(index EQU INDEX_CONSTRAINT_ATTRIBUTES);
return pConstraintAttributes_;
}
//
// Scans (parses) input external-format schema name.
//
// This method assumes that the parameter externalSchemaName only
// contains the external-format schema name. The syntax of an
// schema name is
//
// [ <catalog-name-part> ] . <schema-name-part>
//
// A schema name part must be specified; the catalog name part is optional.
//
// The method returns the number of bytes scanned via the parameter
// bytesScanned. If the scanned schema name is illegal, bytesScanned
// contains the number of bytes examined when the name is determined
// to be invalid.
//
// If the specified external-format schema name is valid, this method
// returns TRUE and saves the parsed ANSI SQL name part into data
// members catalogNamePart_ and schemaNamePart_; otherwise, it returns
// FALSE and does not changes the contents of the data members.
//
NABoolean
ComSchemaName::scan(const NAString &externalSchemaName,
size_t &bytesScanned)
{
size_t count;
size_t externalSchemaNameLen = externalSchemaName.length();
bytesScanned = 0;
#define COPY_VALIDATED_STRING(x) \
ComAnsiNamePart(x, ComAnsiNamePart::INTERNAL_FORMAT)
if (( SqlParser_Initialized() && SqlParser_NAMETYPE == DF_NSK) ||
(!SqlParser_Initialized() && *externalSchemaName.data() == '\\')) {
ComMPLoc loc(externalSchemaName);
switch (loc.getFormat()) {
case ComMPLoc::SUBVOL:
catalogNamePart_ = COPY_VALIDATED_STRING(loc.getSysDotVol());
schemaNamePart_ = COPY_VALIDATED_STRING(loc.getSubvolName());
bytesScanned = externalSchemaNameLen;
return TRUE;
case ComMPLoc::FILE:
if (!loc.hasSubvolName()) {
catalogNamePart_ = "";
schemaNamePart_ = COPY_VALIDATED_STRING(loc.getFileName());
bytesScanned = externalSchemaNameLen;
return TRUE;
}
}
}
// Each ComAnsiNamePart ctor below must be preceded by "count = 0;"
// -- see ComAnsiNamePart.cpp, and for a better scan implementation,
// see ComObjectName::scan() + ComObjectName(bytesScanned) ctor.
// ---------------------------------------------------------------------
// Scan the leftmost ANSI SQL name part.
// ---------------------------------------------------------------------
count = 0;
ComAnsiNamePart part1(externalSchemaName, count);
bytesScanned += count;
if (NOT part1.isValid())
return FALSE;
if (bytesScanned >= externalSchemaNameLen)
{
ComASSERT(bytesScanned == externalSchemaNameLen);
schemaNamePart_ = part1;
return TRUE; // "sch"
}
// Get past the period separator
if (NOT ComSqlText.isPeriod(externalSchemaName[bytesScanned++]))
return FALSE;
// ---------------------------------------------------------------------
// Scan the last ANSI SQL name part
// ---------------------------------------------------------------------
#pragma nowarn(1506) // warning elimination
Int32 remainingLen = externalSchemaNameLen - bytesScanned;
#pragma warn(1506) // warning elimination
NAString remainingName = externalSchemaName(bytesScanned, remainingLen);
count = 0;
ComAnsiNamePart part2(remainingName, count);
bytesScanned += count;
if (NOT part2.isValid())
return FALSE;
if (bytesScanned == externalSchemaNameLen)
{
catalogNamePart_ = part1;
schemaNamePart_ = part2;
return TRUE; // "cat.sch"
}
// The specified external-format object name contains some extra
// trailing characters -- illegal.
//
return FALSE;
} // ComSchemaName::scan()
ExprNode *
ElemDDLColDefault::getChild(Lng32 index)
{
ComASSERT(index EQU INDEX_DEFAULT_VALUE_EXPR);
return defaultValueExpr_;
}
ExprNode *
ElemDDLPartitionSystem::getChild(Lng32 index)
{
ComASSERT(index >= 0 AND index < getArity());
return children_[index];
}
ExprNode *
StmtDDLRoleGrant::getChild(Lng32 index)
{
ComASSERT(index >= 0 AND index < getArity());
return children_[index];
}
void
ElemDDLColDef::setDefaultAttribute(ElemDDLNode * pColDefaultNode)
{
ElemDDLColDefault * pColDefault = NULL;
ComBoolean isIdentityColumn = FALSE;
NAType * pColumnDataType = columnDataType_;
if (pColDefaultNode NEQ NULL)
{
ComASSERT(pColDefaultNode->castToElemDDLColDefault() NEQ NULL);
pColDefault = pColDefaultNode->castToElemDDLColDefault();
}
if (pColDefault NEQ NULL)
{
switch (pColDefault->getColumnDefaultType())
{
case ElemDDLColDefault::COL_NO_DEFAULT:
defaultClauseStatus_ = NO_DEFAULT_CLAUSE_SPEC;
break;
case ElemDDLColDefault::COL_DEFAULT:
{
defaultClauseStatus_ = DEFAULT_CLAUSE_SPEC;
if (pColDefault->getSGOptions())
{
isIdentityColumn = TRUE;
pSGOptions_ = pColDefault->getSGOptions();
pSGLocation_ = pColDefault->getSGLocation();
}
else
{
ComASSERT(pColDefault->getDefaultValueExpr() NEQ NULL);
pDefault_ = pColDefault->getDefaultValueExpr();
}
// The cast ItemExpr to ConstValue for (ConstValue *)pDefault_;
// statement below sets arbitary value for the isNULL_.
// Bypass these checks for ID column (basically ITM_IDENTITY).
ConstValue *cvDef = (ConstValue *)pDefault_;
if ((cvDef && !cvDef->isNull()) && (!isIdentityColumn))
{
const NAType *cvTyp = cvDef->getType();
NABoolean isAnErrorAlreadyIssued = FALSE;
if ( cvTyp->getTypeQualifier() == NA_CHARACTER_TYPE )
{
CharInfo::CharSet defaultValueCS = ((const CharType *)cvTyp)->getCharSet();
// Always check for INFER_CHARSET setting before the ICAT setting.
NAString inferCharSetFlag;
if (getCharSetInferenceSetting(inferCharSetFlag) == TRUE &&
NOT cvDef->isStrLitWithCharSetPrefixSpecified())
{
if (pColumnDataType->getTypeQualifier() == NA_CHARACTER_TYPE
&& ((const CharType *)pColumnDataType)->getCharSet() == CharInfo::UCS2
&& SqlParser_DEFAULT_CHARSET == CharInfo::UCS2
&& defaultValueCS == CharInfo::ISO88591
)
{
*SqlParser_Diags << DgSqlCode(-1186)
<< DgColumnName(ToAnsiIdentifier(getColumnName()))
<< DgString0(pColumnDataType->getTypeSQLname(TRUE/*terse*/))
<< DgString1(cvTyp->getTypeSQLname(TRUE/*terse*/));
isAnErrorAlreadyIssued = TRUE;
}
else
{
cvTyp = cvDef -> pushDownType(*columnDataType_, NA_CHARACTER_TYPE);
}
}
else if (CmpCommon::getDefault(ALLOW_IMPLICIT_CHAR_CASTING) == DF_ON &&
NOT cvDef->isStrLitWithCharSetPrefixSpecified() &&
cvTyp->getTypeQualifier() == NA_CHARACTER_TYPE &&
SqlParser_DEFAULT_CHARSET == CharInfo::ISO88591 &&
defaultValueCS == CharInfo::UnknownCharSet)
{
cvTyp = cvDef -> pushDownType(*columnDataType_, NA_CHARACTER_TYPE);
}
} // column default value has character data type
if (NOT isAnErrorAlreadyIssued &&
pColumnDataType->getTypeQualifier() == NA_CHARACTER_TYPE &&
cvTyp->getTypeQualifier() == NA_CHARACTER_TYPE &&
(
CmpCommon::getDefault(ALLOW_IMPLICIT_CHAR_CASTING) == DF_ON ||
NOT cvDef->isStrLitWithCharSetPrefixSpecified()))
{
const CharType *cdCharType = (const CharType *)pColumnDataType;
const CharType *cvCharType = (const CharType *)cvTyp;
CharInfo::CharSet cdCharSet = cdCharType->getCharSet(); // cd = column definition
CharInfo::CharSet cvCharSet = cvCharType->getCharSet(); // cv = constant value
if (cvCharSet == CharInfo::ISO88591) // default value is a _ISO88591 str lit
{
}
else if ( (cvCharSet == CharInfo::UNICODE || // default value is a _UCS2 string literal
cvCharSet == CharInfo::UTF8) && // or a _UTF8 string literal
cdCharSet != cvCharSet )
{
//
// Check to see if all characters in the specified column default
// string literal value can be successfully converted/translated
// to the actual character set of the column.
//
char buf[2032]; // the output buffer - should be big enough
buf[0] = '\0';
enum cnv_charset eCnvCS = convertCharsetEnum( cdCharSet );
const char * pInStr = cvDef->getRawText()->data();
Int32 inStrLen = cvDef->getRawText()->length();
char * p1stUnstranslatedChar = NULL;
UInt32 outStrLenInBytes = 0;
unsigned charCount = 0; // number of characters translated/converted
Int32 cnvErrStatus = 0;
char *pSubstitutionChar = NULL;
Int32 convFlags = 0;
if ( cvCharSet == CharInfo::UNICODE )
{
cnvErrStatus =
UTF16ToLocale
( cnv_version1 // in - const enum cnv_version version
, pInStr // in - const char *in_bufr
, inStrLen // in - const int in_len
, buf // out - const char *out_bufr
, 2016 // in - const int out_len
, eCnvCS // in - enum cnv_charset charset
, p1stUnstranslatedChar // out - char * & first_untranslated_char
, &outStrLenInBytes // out - unsigned int *output_data_len_p
, convFlags // in - const int cnv_flags
, (Int32)TRUE // in - const int addNullAtEnd_flag
, (Int32)FALSE // in - const int allow_invalids
, &charCount // out - unsigned int * translated_char_cnt_p
, pSubstitutionChar // in - const char *substitution_char
);
}
else // cvCharSet must be CharInfo::UTF8
{
cnvErrStatus =
UTF8ToLocale
( cnv_version1 // in - const enum cnv_version version
, pInStr // in - const char *in_bufr
, inStrLen // in - const int in_len
, buf // out - const char *out_bufr
, 2016 // in - const int out_len
, eCnvCS // in - enum cnv_charset charset
, p1stUnstranslatedChar // out - char * & first_untranslated_char
, &outStrLenInBytes // out - unsigned int *output_data_len_p
, (Int32)TRUE // in - const int addNullAtEnd_flag
, (Int32)FALSE // in - const int allow_invalids
, &charCount // out - unsigned int * translated_char_cnt_p
, pSubstitutionChar // in - const char *substitution_char
);
}
switch (cnvErrStatus)
{
case 0: // success
case CNV_ERR_NOINPUT: // an empty input string will get this error code
{
ConstValue *pMBStrLitConstValue ;
// convert the string literal saved in cvDef (column default value)
// from UNICODE (e.g. UTF16) to the column character data type
if ( cdCharSet != CharInfo::UNICODE)
{
NAString mbs2(buf, PARSERHEAP()); // note that buf is NULL terminated
pMBStrLitConstValue =
new(PARSERHEAP()) ConstValue ( mbs2
, cdCharSet // use this for str lit prefix
, CharInfo::DefaultCollation
, CharInfo::COERCIBLE
, PARSERHEAP()
);
}
else
{
NAWString mbs2((NAWchar*)buf, PARSERHEAP()); // note that buf is NULL terminated
pMBStrLitConstValue =
new(PARSERHEAP()) ConstValue ( mbs2
, cdCharSet // use this for str lit prefix
, CharInfo::DefaultCollation
, CharInfo::COERCIBLE
, PARSERHEAP()
);
}
delete pDefault_; // deallocate the old ConstValue object
cvDef = NULL; // do not use cvDef anymore
pDefault_ = pMBStrLitConstValue;
pColDefault->setDefaultValueExpr(pDefault_);
}
break;
case CNV_ERR_INVALID_CHAR:
{
// 1401 == CAT_UNABLE_TO_CONVERT_COLUMN_DEFAULT_VALUE_TO_CHARSET
*SqlParser_Diags << DgSqlCode(-1401)
<< DgColumnName(ToAnsiIdentifier(getColumnName()))
<< DgString0(CharInfo::getCharSetName(cdCharSet));
}
break;
case CNV_ERR_BUFFER_OVERRUN: // output buffer not big enough
case CNV_ERR_INVALID_CS:
default:
CMPABORT_MSG("Parser internal logic error");
break;
} // switch
}
else if(!pColumnDataType->isCompatible(*cvTyp))
{
if (NOT isAnErrorAlreadyIssued)
{
*SqlParser_Diags << DgSqlCode(-1186)
<< DgColumnName(ToAnsiIdentifier(getColumnName()))
<< DgString0(pColumnDataType->getTypeSQLname(TRUE/*terse*/))
<< DgString1(cvTyp->getTypeSQLname(TRUE/*terse*/));
isAnErrorAlreadyIssued = TRUE;
}
}
} // column has character data type
else
// if interval data type, the default value must have the same
// interval qualifier as the column.
if (NOT isAnErrorAlreadyIssued &&
(!pColumnDataType->isCompatible(*cvTyp) ||
(pColumnDataType->getTypeQualifier() == NA_INTERVAL_TYPE &&
pColumnDataType->getFSDatatype() != cvTyp->getFSDatatype())))
{
*SqlParser_Diags << DgSqlCode(-1186)
<< DgColumnName(ToAnsiIdentifier(getColumnName()))
<< DgString0(pColumnDataType->getTypeSQLname(TRUE/*terse*/))
<< DgString1(cvTyp->getTypeSQLname(TRUE/*terse*/));
isAnErrorAlreadyIssued = TRUE;
}
}
}
break;
case ElemDDLColDefault::COL_COMPUTED_DEFAULT:
{
defaultClauseStatus_ = DEFAULT_CLAUSE_SPEC;
computedDefaultExpr_ = pColDefault->getComputedDefaultExpr();
}
break;
default:
CMPABORT_MSG("Parser internal logic error");
break;
}
}
}
// -----------------------------------------------------------------------
// member functions for class StmtDDLSchGrant
// -----------------------------------------------------------------------
StmtDDLSchGrant::StmtDDLSchGrant(ElemDDLNode * pPrivileges,
const ElemDDLSchemaName & aSchemaNameParseNode,
ElemDDLNode * pGranteeList,
ElemDDLNode * pWithGrantOption,
ElemDDLNode * pByGrantorOption,
CollHeap * heap)
: StmtDDLNode(DDL_GRANT_SCHEMA),
schemaName_(heap),
schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap),
isAllDMLPrivileges_(FALSE),
isAllDDLPrivileges_(FALSE),
isAllOtherPrivileges_(FALSE),
isWithGrantOptionSpec_(FALSE),
privActArray_(heap),
granteeArray_(heap),
isByGrantorOptionSpec_(FALSE),
byGrantor_(NULL)
{
if (schemaQualName_.getSchemaName().isNull())
{
schemaQualName_ = ActiveSchemaDB()->getDefaultSchema();
}
setChild(INDEX_PRIVILEGES, pPrivileges);
setChild(INDEX_GRANTEE_LIST, pGranteeList);
setChild(INDEX_WITH_GRANT_OPTION, pWithGrantOption);
setChild(INDEX_BY_GRANTOR_OPTION, pByGrantorOption);
//objectName_ = objectQualName_.getQualifiedNameAsAnsiString();
//
// inserts pointers to parse nodes representing privilege
// actions to privActArray_ so the user can access the
// information about privilege actions easier.
//
ComASSERT(pPrivileges NEQ NULL);
ElemDDLPrivileges * pPrivsNode = pPrivileges->castToElemDDLPrivileges();
ComASSERT(pPrivsNode NEQ NULL);
if (pPrivsNode->isAllPrivileges())
{
isAllDMLPrivileges_ = TRUE;
isAllDDLPrivileges_ = TRUE;
isAllOtherPrivileges_ = TRUE;
}
if (pPrivsNode->isAllDMLPrivileges())
{
isAllDMLPrivileges_ = TRUE;
}
if (pPrivsNode->isAllDDLPrivileges())
{
isAllDDLPrivileges_ = TRUE;
}
if (pPrivsNode->isAllOtherPrivileges())
{
isAllOtherPrivileges_ = TRUE;
}
ElemDDLNode * pPrivActs = pPrivsNode->getPrivilegeActionList();
if (pPrivActs)
{
for (CollIndex i = 0; i < pPrivActs->entries(); i++)
{
privActArray_.insert((*pPrivActs)[i]->castToElemDDLPrivAct());
}
}
//
// copies pointers to parse nodes representing grantee
// to granteeArray_ so the user can access the information
// easier.
//
ComASSERT(pGranteeList NEQ NULL);
for (CollIndex i = 0; i < pGranteeList->entries(); i++)
{
granteeArray_.insert((*pGranteeList)[i]->castToElemDDLGrantee());
}
//
// looks for With Grant option phrase
//
if (pWithGrantOption NEQ NULL)
{
isWithGrantOptionSpec_ = TRUE;
}
if ( pByGrantorOption NEQ NULL )
{
isByGrantorOptionSpec_ = TRUE;
byGrantor_ = pByGrantorOption->castToElemDDLGrantee();
}
} // StmtDDLSchGrant::StmtDDLSchGrant()
ExprNode *
StmtDDLInitializeSQL::getChild(Lng32 index)
{
ComASSERT ((index >= 0) && index < getArity());
return children_[index];
}
StmtDDLPublish::StmtDDLPublish(ElemDDLNode * pPrivileges,
const QualifiedName & objectName,
const NAString & synonymName,
ComBoolean isRole,
ElemDDLNode * pGranteeList,
ComBoolean isPublish,
CollHeap * heap)
: StmtDDLNode(DDL_PUBLISH),
objectName_(heap),
objectQualName_(objectName, heap),
synonymName_(synonymName, heap),
isSynonymNameSpec_(FALSE),
isRoleList_(isRole),
isPublish_(isPublish),
isAllPrivileges_(FALSE),
privActArray_(heap),
granteeArray_(heap)
{
setChild(PUBLISH_PRIVILEGES, pPrivileges);
setChild(PUBLISH_GRANTEE_LIST, pGranteeList);
objectName_ = objectQualName_.getQualifiedNameAsAnsiString();
if (!synonymName.isNull())
isSynonymNameSpec_ = TRUE;
//
// inserts pointers to parse nodes representing privilege
// actions to privActArray_ so the user can access the
// information about privilege actions easier.
//
ComASSERT(pPrivileges NEQ NULL);
ElemDDLPrivileges * pPrivsNode = pPrivileges->castToElemDDLPrivileges();
ComASSERT(pPrivsNode NEQ NULL);
if (pPrivsNode->isAllPrivileges())
{
isAllPrivileges_ = TRUE;
}
else
{
ElemDDLNode * pPrivActs = pPrivsNode->getPrivilegeActionList();
for (CollIndex i = 0; i < pPrivActs->entries(); i++)
{
ElemDDLPrivAct *pPrivAct = (*pPrivActs)[i]->castToElemDDLPrivAct();
privActArray_.insert(pPrivAct);
}
}
//
// copies pointers to parse nodes representing grantee
// to granteeArray_ so the user can access the information
// easier.
//
ComASSERT(pGranteeList NEQ NULL);
for (CollIndex i = 0; i < pGranteeList->entries(); i++)
{
granteeArray_.insert((*pGranteeList)[i]->castToElemDDLGrantee());
}
} // StmtDDLPublish::StmtDDLPublish()
StmtDDLGrant::StmtDDLGrant(ElemDDLNode * pPrivileges,
const QualifiedName & objectName,
ElemDDLNode * pGranteeList,
ElemDDLNode * pWithGrantOption,
ElemDDLNode * pByGrantorOption,
QualifiedName * actionName,
CollHeap * heap)
: StmtDDLNode(DDL_GRANT),
objectName_(heap),
objectQualName_(objectName, heap),
isAllPrivileges_(FALSE),
isWithGrantOptionSpec_(FALSE),
privActArray_(heap),
actionQualName_(actionName),
granteeArray_(heap),
isByGrantorOptionSpec_(FALSE),
byGrantor_(NULL)
{
setChild(INDEX_PRIVILEGES, pPrivileges);
setChild(INDEX_GRANTEE_LIST, pGranteeList);
setChild(INDEX_WITH_GRANT_OPTION, pWithGrantOption);
setChild(INDEX_BY_GRANTOR_OPTION, pByGrantorOption);
objectName_ = objectQualName_.getQualifiedNameAsAnsiString();
//
// inserts pointers to parse nodes representing privilege
// actions to privActArray_ so the user can access the
// information about privilege actions easier.
//
ComASSERT(pPrivileges NEQ NULL);
ElemDDLPrivileges * pPrivsNode = pPrivileges->castToElemDDLPrivileges();
ComASSERT(pPrivsNode NEQ NULL);
if (pPrivsNode->isAllPrivileges())
{
isAllPrivileges_ = TRUE;
}
else
{
ElemDDLNode * pPrivActs = pPrivsNode->getPrivilegeActionList();
for (CollIndex i = 0; i < pPrivActs->entries(); i++)
{
ElemDDLPrivAct *pPrivAct = (*pPrivActs)[i]->castToElemDDLPrivAct();
privActArray_.insert(pPrivAct);
if (pPrivAct->isDDLPriv())
privActArray_.setHasDDLPriv(TRUE);
}
}
//
// copies pointers to parse nodes representing grantee
// to granteeArray_ so the user can access the information
// easier.
//
ComASSERT(pGranteeList NEQ NULL);
for (CollIndex i = 0; i < pGranteeList->entries(); i++)
{
granteeArray_.insert((*pGranteeList)[i]->castToElemDDLGrantee());
}
//
// looks for With Grant option phrase
//
if (pWithGrantOption NEQ NULL)
{
isWithGrantOptionSpec_ = TRUE;
}
if ( pByGrantorOption NEQ NULL )
{
isByGrantorOptionSpec_ = TRUE;
byGrantor_ = pByGrantorOption->castToElemDDLGrantee();
}
} // StmtDDLGrant::StmtDDLGrant()
NATraceList
StmtDDLSchRevoke::getDetailInfo() const
{
NAString detailText;
NATraceList detailTextList;
//
// object name
//
detailTextList.append(displayLabel1()); // object name
//
// privileges
//
StmtDDLSchRevoke * localThis = (StmtDDLSchRevoke *)this;
detailTextList.append(localThis->getChild(INDEX_PRIVILEGES)
->castToElemDDLNode()
->castToElemDDLPrivileges()
->getDetailInfo());
//
// grantee list
//
const ElemDDLGranteeArray & granteeArray = getGranteeArray();
detailText = "Grantee list [";
detailText += LongToNAString((Lng32)granteeArray.entries());
detailText += " element(s)]";
detailTextList.append(detailText);
for (CollIndex i = 0; i < granteeArray.entries(); i++)
{
detailText = "[grantee ";
detailText += LongToNAString((Lng32)i);
detailText += "]";
detailTextList.append(detailText);
ComASSERT(granteeArray[i] NEQ NULL AND
granteeArray[i]->castToElemDDLGrantee() NEQ NULL);
detailTextList.append(" ", granteeArray[i]->castToElemDDLGrantee()
->getDetailInfo());
}
//
// grant option for
//
detailText = "is grant option for? ";
detailText += YesNo(isGrantOptionForSpecified());
detailTextList.append(detailText);
//
// drop behavior
//
detailTextList.append(displayLabel2()); // drop behavior
return detailTextList;
} // StmtDDLSchRevoke::getDetailInfo
ExprNode *
StmtDDLSchRevoke::getChild(Lng32 index)
{
ComASSERT(index >= 0 AND index < getArity());
return children_[index];
}
StmtDDLSchRevoke::StmtDDLSchRevoke(NABoolean isGrantOptionFor,
ElemDDLNode * pPrivileges,
const ElemDDLSchemaName & aSchemaNameParseNode,
ElemDDLNode * pGranteeList,
ComDropBehavior dropBehavior,
ElemDDLNode * pByGrantorOption,
CollHeap * heap)
: StmtDDLNode(DDL_REVOKE_SCHEMA),
schemaName_(heap),
schemaQualName_(aSchemaNameParseNode.getSchemaName(), heap),
isAllDDLPrivileges_(FALSE),
isAllDMLPrivileges_(FALSE),
isAllOtherPrivileges_(FALSE),
isGrantOptionForSpec_(isGrantOptionFor),
dropBehavior_(dropBehavior),
privActArray_(heap),
granteeArray_(heap),
isByGrantorOptionSpec_(FALSE),
byGrantor_(NULL)
{
setChild(INDEX_PRIVILEGES, pPrivileges);
setChild(INDEX_GRANTEE_LIST, pGranteeList);
setChild(INDEX_BY_GRANTOR_OPTION, pByGrantorOption);
//
// inserts pointers to parse nodes representing privilege
// actions to privActArray_ so the user can access the
// information about privilege actions easier.
//
ComASSERT(pPrivileges NEQ NULL);
ElemDDLPrivileges * pPrivsNode = pPrivileges->castToElemDDLPrivileges();
ComASSERT(pPrivsNode NEQ NULL);
if (pPrivsNode->isAllPrivileges())
{
isAllDDLPrivileges_ = TRUE;
isAllDMLPrivileges_ = TRUE;
isAllOtherPrivileges_ = TRUE;
}
if (pPrivsNode->isAllDDLPrivileges())
{
isAllDDLPrivileges_ = TRUE;
}
if (pPrivsNode->isAllDMLPrivileges())
{
isAllDMLPrivileges_ = TRUE;
}
if (pPrivsNode->isAllOtherPrivileges())
{
isAllOtherPrivileges_ = TRUE;
}
ElemDDLNode * pPrivActs = pPrivsNode->getPrivilegeActionList();
if (pPrivActs)
{
for (CollIndex i = 0; i < pPrivActs->entries(); i++)
{
privActArray_.insert((*pPrivActs)[i]->castToElemDDLPrivAct());
}
}
//
// copies pointers to parse nodes representing grantee
// to granteeArray_ so the user can access the information
// easier.
//
ComASSERT(pGranteeList NEQ NULL);
for (CollIndex i = 0; i < pGranteeList->entries(); i++)
{
granteeArray_.insert((*pGranteeList)[i]->castToElemDDLGrantee());
}
if ( pByGrantorOption NEQ NULL )
{
isByGrantorOptionSpec_ = TRUE;
byGrantor_ = pByGrantorOption->castToElemDDLGrantee();
}
} // StmtDDLSchRevoke::StmtDDLSchRevoke()
// Gets the length that a given data type would use in the display tool
Lng32 NAType::getDisplayLength(Lng32 datatype,
Lng32 length,
Lng32 precision,
Lng32 scale,
Lng32 heading_len) const
{
Lng32 d_len = 0;
Int32 scale_len = 0;
if (scale > 0)
scale_len = 1;
switch (datatype)
{
case REC_BPINT_UNSIGNED:
// Can set the display size based on precision. For now treat it as
// unsigned smallint
d_len = SQL_USMALL_DISPLAY_SIZE;
break;
case REC_BIN16_SIGNED:
d_len = SQL_SMALL_DISPLAY_SIZE + scale_len;
break;
case REC_BIN16_UNSIGNED:
d_len = SQL_USMALL_DISPLAY_SIZE + scale_len;
break;
case REC_BIN32_SIGNED:
d_len = SQL_INT_DISPLAY_SIZE + scale_len;
break;
case REC_BIN32_UNSIGNED:
d_len = SQL_UINT_DISPLAY_SIZE + scale_len;
break;
case REC_BIN64_SIGNED:
d_len = SQL_LARGE_DISPLAY_SIZE + scale_len;
break;
case REC_BYTE_F_ASCII:
d_len = length;
break;
case REC_BYTE_V_ASCII:
case REC_BYTE_V_ASCII_LONG:
d_len = length;
break;
case REC_DECIMAL_UNSIGNED:
d_len = length + scale_len;
break;
case REC_DECIMAL_LSE:
d_len = length + 1 + scale_len;
break;
case REC_NUM_BIG_SIGNED:
{
SQLBigNum tmp(precision,scale,FALSE,TRUE,FALSE,NULL);
d_len = tmp.getDisplayLength();
}
break;
case REC_NUM_BIG_UNSIGNED:
{
SQLBigNum tmp(precision,scale,FALSE,FALSE,FALSE,NULL);
d_len = tmp.getDisplayLength();
}
break;
case REC_FLOAT32:
case REC_TDM_FLOAT32:
d_len = SQL_REAL_DISPLAY_SIZE;
break;
case REC_FLOAT64:
case REC_TDM_FLOAT64:
d_len = SQL_DOUBLE_PRECISION_DISPLAY_SIZE;
break;
case REC_DATETIME:
/*
switch (precision) {
case SQLDTCODE_DATE:
{
SQLDate tmp(FALSE);
d_len = tmp.getDisplayLength();
}
break;
case SQLDTCODE_TIME:
{
SQLTime tmp(FALSE, (unsigned) scale);
d_len = tmp.getDisplayLength();
}
break;
case SQLDTCODE_TIMESTAMP:
{
SQLTimestamp tmp(FALSE, (unsigned) scale);
d_len = tmp.getDisplayLength();
}
break;
default:
d_len = length;
break;
}
*/
ComASSERT(FALSE);
break;
case REC_INT_YEAR:
case REC_INT_MONTH:
case REC_INT_YEAR_MONTH:
case REC_INT_DAY:
case REC_INT_HOUR:
case REC_INT_DAY_HOUR:
case REC_INT_MINUTE:
case REC_INT_HOUR_MINUTE:
case REC_INT_DAY_MINUTE:
case REC_INT_SECOND:
case REC_INT_MINUTE_SECOND:
case REC_INT_HOUR_SECOND:
case REC_INT_DAY_SECOND:
case REC_INT_FRACTION: {
rec_datetime_field startField;
rec_datetime_field endField;
getIntervalFields(datatype, startField, endField);
SQLInterval interval(FALSE,
startField,
(UInt32) precision,
endField,
(UInt32) scale);
#pragma nowarn(1506) // warning elimination
d_len = interval.getDisplayLength();
#pragma warn(1506) // warning elimination
}
break;
case REC_BLOB:
case REC_CLOB:
d_len = length;
break;
default:
d_len = length;
break;
}
if (d_len >= heading_len)
return d_len;
else
return heading_len;
}
SqlciEnv::SqlciEnv(short serv_type, NABoolean macl_rw_flag)
{
ole_server = serv_type;
logfile = new Logfile;
sqlci_stmts = new SqlciStmts(50);
prepared_stmts = new SqlciList<PrepStmt>;
param_list = new SqlciList<Param>;
pattern_list = new SqlciList<Param>;
define_list = new SqlciList<Define>;
envvar_list = new SqlciList<Envvar>;
cursorList_ = new SqlciList<CursorStmt>;
sqlci_stats = new SqlciStats();
terminal_charset_ = CharInfo::ISO88591;
iso_mapping_charset_ = CharInfo::ISO88591;
default_charset_ = CharInfo::ISO88591;
infer_charset_ = FALSE;
lastDmlStmtStatsType_ = SQLCLIDEV_NO_STATS;
lastExecutedStmt_ = NULL;
statsStmt_ = NULL;
lastAllocatedStmt_ = NULL;
defaultCatalog_ = NULL;
defaultSchema_ = NULL;
doneWithPrologue_ = FALSE;
noBanner_ = FALSE;
setListCount(MAX_LISTCOUNT);
resetSpecialError();
defaultCatAndSch_ = NULL;
userNameFromCommandLine_ = "";
report_env = new SqlciRWEnv(); // initialize the report writer environment variable
cs_env = new SqlciCSEnv(); // initialize the macl environment variable.
// A break flag macl_rw_flag was added to the constructor in order for the SqlciEnv
// constructor not to call the MACL & Report Writer Constructors
// when the SqlciEnv constructor is called after a break key is hit.
// 64-bit: no more report writer and macl
/*
// if (macl_rw_flag) {
// jzLng32 retcode = RW_MXCI_Constructor(report_env->rwEnv(), this);
// if (retcode == ERR)
// SqlciError (SQLCI_RW_UNABLE_TO_GET_CONSTRUCTOR,(ErrorParam *) 0 );
//
// jzLng32 maclretcode = CS_MXCI_Constructor(cs_env->csEnv());
// if (maclretcode == CSERROR)
// SqlciError (SQLCI_CS_UNABLE_TO_GET_CONSTRUCTOR,(ErrorParam *) 0 );
// constructorFlag_ = TRUE;
// }
// else
*/
constructorFlag_ = FALSE;
setMode(SqlciEnv::SQL_); // Set the mode initially to be SQL
showShape_ = FALSE;
eol_seen_on_input = -1;
obey_file = 0;
prev_err_flush_input = 0;
logCommands_ = FALSE;
deallocateStmt_ = FALSE ; // Always set to FALSE.Set to TRUE only in global_sqlci_env if needed.
// Note that interactive_session is overwritten in SqlciEnv::run(infile) ...
// Executing on NT
if ((Int32)cin.tellg() == EOF)
interactive_session = -1; // Std. input is terminal keyboard
else
interactive_session = 0;
cin.clear(); // Always clear() bad results from any tellg()
// Special case for QA testing
// ---------------------------
// If sqlci has been started via an exec, ALWAYS deem it to be interactive.
// Since there is no easy way to determine if we have been exec'ed, we will
// use an environment variable to decide this. Just the existence of this
// variable is enough and the value is immaterial.
if (getenv("QA_TEST_WITH_EXEC")) interactive_session = -1;
#ifndef NDEBUG
// Ensure that SQLCI sqlcode is same as in ExpError.h
ComASSERT(SQL_Canceled == -ABS(EXE_CANCELED));
#endif
prepareOnly_ = NULL;
executeOnly_ = NULL;
}
void
ParDDLLikeOptsCreateTable::setLikeOption(ElemDDLLikeOpt * pLikeOption)
{
ComASSERT(pLikeOption != NULL);
switch (pLikeOption->getOperatorType())
{
case ELM_LIKE_OPT_WITHOUT_CONSTRAINTS_ELEM :
if (isLikeOptWithoutConstraintsSpec_)
{
*SqlParser_Diags << DgSqlCode(-3149);
// "*** Error *** Duplicate WITHOUT CONSTRAINTS phrases "
// << "in LIKE clause" << endl;
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithoutConstraints() != NULL);
isLikeOptWithoutConstraints_ = TRUE;
isLikeOptWithoutConstraintsSpec_ = TRUE;
break;
case ELM_LIKE_OPT_WITH_HEADINGS_ELEM :
if (isLikeOptWithHeadingsSpec_)
{
*SqlParser_Diags << DgSqlCode(-3150);
// cout << "*** Error *** Duplicate WITH HEADING phrases "
// << "in LIKE clause" << endl;
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithHeadings() != NULL);
isLikeOptWithHeadings_ = TRUE;
isLikeOptWithHeadingsSpec_ = TRUE;
break;
case ELM_LIKE_OPT_WITH_HORIZONTAL_PARTITIONS_ELEM :
if (isLikeOptWithHorizontalPartitionsSpec_)
{
*SqlParser_Diags << DgSqlCode(-3151);
//cout << "*** Error *** Duplicate WITH HORIZONTAL PARTITIONS phrases "
// << "in LIKE clause" << endl;
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithHorizontalPartitions() != NULL);
isLikeOptWithHorizontalPartitions_ = TRUE;
isLikeOptWithHorizontalPartitionsSpec_ = TRUE;
break;
case ELM_LIKE_OPT_WITHOUT_SALT_ELEM :
if (isLikeOptWithoutSaltSpec_)
{
// ERROR[3152] Duplicate WITHOUT SALT phrases were specified
// in LIKE clause in CREATE TABLE statement.
*SqlParser_Diags << DgSqlCode(-3152) << DgString0("SALT");
}
if (isLikeOptSaltClauseSpec_)
{
// ERROR[3154] The WITHOUT SALT clause is not allowed with the SALT clause.
*SqlParser_Diags << DgSqlCode(-3154) << DgString0("WITHOUT SALT") << DgString1("SALT");
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithoutSalt() != NULL);
isLikeOptWithoutSalt_ = TRUE;
isLikeOptWithoutSaltSpec_ = TRUE;
break;
case ELM_LIKE_OPT_SALT_CLAUSE_ELEM:
{ // braces needed since we declare some variables in this case
if (isLikeOptSaltClauseSpec_)
{
// ERROR[3183] Duplicate SALT clauses were specified.
*SqlParser_Diags << DgSqlCode(-3183) << DgString0("SALT");
}
if (isLikeOptWithoutSaltSpec_)
{
// ERROR[3154] The WITHOUT SALT clause is not allowed with the SALT clause.
*SqlParser_Diags << DgSqlCode(-3154) << DgString0("WITHOUT SALT") << DgString1("SALT");
}
ComASSERT(pLikeOption->castToElemDDLLikeSaltClause() != NULL);
isLikeOptSaltClauseSpec_ = TRUE;
isLikeOptSaltClause_ = new (PARSERHEAP()) NAString();
ElemDDLLikeSaltClause * saltClauseWrapper = pLikeOption->castToElemDDLLikeSaltClause();
const ElemDDLSaltOptionsClause * saltOptions = saltClauseWrapper->getSaltClause();
saltOptions->unparseIt(*isLikeOptSaltClause_ /* side-effected */);
isLikeOptWithoutSalt_ = TRUE; // suppresses any SALT clause from the source table
}
break;
case ELM_LIKE_OPT_WITHOUT_DIVISION_ELEM :
if (isLikeOptWithoutDivisionSpec_)
{
// ERROR[3152] Duplicate WITHOUT DIVISION phrases were specified
// in LIKE clause in CREATE TABLE statement.
*SqlParser_Diags << DgSqlCode(-3152) << DgString0("DIVISION");
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithoutDivision() != NULL);
isLikeOptWithoutDivision_ = TRUE;
isLikeOptWithoutDivisionSpec_ = TRUE;
break;
case ELM_LIKE_OPT_LIMIT_COLUMN_LENGTH:
{
if (isLikeOptLimitColumnLengthSpec_)
{
// ERROR[3152] Duplicate LIMIT COLUMN LENGTH phrases were specified
// in LIKE clause in CREATE TABLE statement.
*SqlParser_Diags << DgSqlCode(-3152) << DgString0("LIMIT COLUMN LENGTH");
}
ComASSERT(pLikeOption->castToElemDDLLikeLimitColumnLength() != NULL);
ElemDDLLikeLimitColumnLength * limitColumnLength =
pLikeOption->castToElemDDLLikeLimitColumnLength();
isLikeOptColumnLengthLimit_ = limitColumnLength->getColumnLengthLimit();
isLikeOptLimitColumnLengthSpec_ = TRUE;
}
break;
case ELM_LIKE_OPT_WITHOUT_ROW_FORMAT_ELEM :
if (isLikeOptWithoutRowFormatSpec_)
{
// ERROR[3152] Duplicate WITHOUT ROW FORMAT phrases were specified
// in LIKE clause in CREATE TABLE statement.
*SqlParser_Diags << DgSqlCode(-3152) << DgString0("ROW FORMAT");
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithoutRowFormat() != NULL);
isLikeOptWithoutRowFormat_ = TRUE;
isLikeOptWithoutRowFormatSpec_ = TRUE;
break;
default :
NAAbort("ParDDLLikeOpts.C", __LINE__, "internal logic error");
break;
}
} // ParDDLLikeOptsCreateTable::setLikeOption()
ExprNode *
ElemDDLList::getChild(Lng32 index)
{
ComASSERT(index >= 0 AND index < getArity());
return children_[index];
}
void
ParDDLLikeOptsCreateTable::setLikeOption(ElemDDLLikeOpt * pLikeOption)
{
ComASSERT(pLikeOption != NULL);
switch (pLikeOption->getOperatorType())
{
case ELM_LIKE_OPT_WITHOUT_CONSTRAINTS_ELEM :
if (isLikeOptWithoutConstraintsSpec_)
{
*SqlParser_Diags << DgSqlCode(-3149);
// "*** Error *** Duplicate WITHOUT CONSTRAINTS phrases "
// << "in LIKE clause" << endl;
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithoutConstraints() != NULL);
isLikeOptWithoutConstraints_ = TRUE;
isLikeOptWithoutConstraintsSpec_ = TRUE;
break;
case ELM_LIKE_OPT_WITH_HEADINGS_ELEM :
if (isLikeOptWithHeadingsSpec_)
{
*SqlParser_Diags << DgSqlCode(-3150);
// cout << "*** Error *** Duplicate WITH HEADING phrases "
// << "in LIKE clause" << endl;
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithHeadings() != NULL);
isLikeOptWithHeadings_ = TRUE;
isLikeOptWithHeadingsSpec_ = TRUE;
break;
case ELM_LIKE_OPT_WITH_HORIZONTAL_PARTITIONS_ELEM :
if (isLikeOptWithHorizontalPartitionsSpec_)
{
*SqlParser_Diags << DgSqlCode(-3151);
//cout << "*** Error *** Duplicate WITH HORIZONTAL PARTITIONS phrases "
// << "in LIKE clause" << endl;
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithHorizontalPartitions() != NULL);
isLikeOptWithHorizontalPartitions_ = TRUE;
isLikeOptWithHorizontalPartitionsSpec_ = TRUE;
break;
case ELM_LIKE_OPT_WITHOUT_SALT_ELEM :
if (isLikeOptWithoutSaltSpec_)
{
// ERROR[3152] Duplicate WITHOUT SALT phrases were specified
// in LIKE clause in CREATE TABLE statement.
*SqlParser_Diags << DgSqlCode(-3152) << DgString0("SALT");
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithoutSalt() != NULL);
isLikeOptWithoutSalt_ = TRUE;
isLikeOptWithoutSaltSpec_ = TRUE;
break;
case ELM_LIKE_OPT_WITHOUT_DIVISION_ELEM :
if (isLikeOptWithoutDivisionSpec_)
{
// ERROR[3152] Duplicate WITHOUT DIVISION phrases were specified
// in LIKE clause in CREATE TABLE statement.
*SqlParser_Diags << DgSqlCode(-3152) << DgString0("DIVISION");
}
ComASSERT(pLikeOption->castToElemDDLLikeOptWithoutDivision() != NULL);
isLikeOptWithoutDivision_ = TRUE;
isLikeOptWithoutDivisionSpec_ = TRUE;
break;
default :
NAAbort("ParDDLLikeOpts.C", __LINE__, "internal logic error");
break;
}
} // ParDDLLikeOptsCreateTable::setLikeOption()
void
ElemDDLColDef::setColumnAttribute(ElemDDLNode * pColAttr)
{
switch(pColAttr->getOperatorType())
{
case ELM_COL_HEADING_ELEM :
if (isHeadingSpec_)
{
// Duplicate HEADING clauses in column definition.
*SqlParser_Diags << DgSqlCode(-3051)
<< DgColumnName(ToAnsiIdentifier(getColumnName()));
}
ComASSERT(pColAttr->castToElemDDLColHeading() NEQ NULL);
heading_ = pColAttr->castToElemDDLColHeading()->getColumnHeading();
isHeadingSpec_ = TRUE;
// Report an error if heading_ is too long.
if (heading_.length() > ElemDDLColHeading::maxHeadingLength)
{
*SqlParser_Diags << DgSqlCode(-3132)
<< DgColumnName(ToAnsiIdentifier(getColumnName()));
}
break;
case ELM_CONSTRAINT_CHECK_ELEM :
ComASSERT(pColAttr->castToElemDDLConstraintCheck() NEQ NULL);
columnConstraintArray_.insert(pColAttr->castToElemDDLConstraint());
break;
case ELM_CONSTRAINT_NOT_NULL_ELEM :
ComASSERT(pColAttr->castToElemDDLConstraintNotNull() NEQ NULL);
if (isNotNullSpec_)
{
// Duplicate NOT NULL clauses in column definition.
*SqlParser_Diags << DgSqlCode(-3052)
<< DgString0("NOT NULL")
<< DgColumnName(ToAnsiIdentifier(getColumnName()));
}
isNotNullSpec_ = TRUE;
pConstraintNotNull_ = pColAttr->castToElemDDLConstraintNotNull();
if (NOT pConstraintNotNull_->isDroppable())
{
isNotNullNondroppable_ = TRUE;
if (columnDataType_)
columnDataType_->setNullable(FALSE);
}
// Note that we do not insert pConstraintNotNull_ into
// columnConstraintArray_ even though Not Null constraint is
// also a column constraint. The user can use the accessors
// getIsConstraintNotNullSpecified and getConstraintNotNull
// instead.
break;
case ELM_LOGGABLE:
ComASSERT( NULL NEQ pColAttr->castToElemDDLLoggable())
if(TRUE == isLoggableSpec_)
{
// Duplicate LOGGABLE in column definition.
*SqlParser_Diags << DgSqlCode(-12064)
<< DgColumnName(ToAnsiIdentifier(getColumnName()));
}
isLoggableSpec_ = TRUE;
isLoggable_ = pColAttr->castToElemDDLLoggable()->getIsLoggable();
break;
case ELM_CONSTRAINT_PRIMARY_KEY_COLUMN_ELEM :
{
ComASSERT(pColAttr->castToElemDDLConstraintPKColumn() NEQ NULL);
ComASSERT(pColAttr->castToElemDDLConstraintPKColumn()
->getConstraintKind()
EQU ElemDDLConstraint::COLUMN_CONSTRAINT_DEF);
if (isPrimaryKeySpec_)
{
// Duplicate PRIMARY KEY clauses in column definition.
*SqlParser_Diags << DgSqlCode(-3053)
<< DgColumnName(ToAnsiIdentifier(getColumnName()));
}
isPrimaryKeySpec_ = TRUE;
ElemDDLConstraintPKColumn * pColPKConstraint =
pColAttr->castToElemDDLConstraintPKColumn();
//
// Copies the pointer to the parse node representing the column
// primary key constraint to pConstraintPK_ so the user (caller)
// can access the information easier. Note that this pointer is
// not inserted into columnConstraintArray_ because primary key
// constraint is special. (There can only be one primary key
// constraint associating with a table.) The user (caller) can
// use method getIsConstraintPKSpecified() and getConstraintPK()
// to get the primary key constraint information.
//
pConstraintPK_ = pColPKConstraint;
// The column name is not specified in the column primary key
// constraint definition. To make the user (caller) to access
// to this information easier, creates a parse node containing
// the column name.
ComASSERT(pColPKConstraint->getColumnRefList() EQU NULL);
ElemDDLColRef * pColRef = new(PARSERHEAP())
ElemDDLColRef(getColumnName(),
pColPKConstraint->
getColumnOrdering(),
PARSERHEAP());
pColPKConstraint->setColumnRefList(pColRef);
primaryKeyColRefArray_.insert(pColRef);
}
break;
case ELM_CONSTRAINT_REFERENTIAL_INTEGRITY_ELEM :
{
ComASSERT(pColAttr->castToElemDDLConstraintRI() NEQ NULL);
ComASSERT(pColAttr->castToElemDDLConstraintRI()->getConstraintKind()
EQU ElemDDLConstraint::COLUMN_CONSTRAINT_DEF);
columnConstraintArray_.insert(pColAttr->castToElemDDLConstraint());
//
// The column name is not specified in the column referential
// integrity constraint definition. To make the user (caller)
// to access to this information easier, creates a parse node
// containing the column name.
//
ElemDDLConstraintRI * pColRIConstraint =
pColAttr->castToElemDDLConstraintRI();
ComASSERT(pColRIConstraint->getReferencingColumnNameList() EQU NULL);
ElemDDLColName * pColName = new(PARSERHEAP())
ElemDDLColName(getColumnName());
pColRIConstraint->setReferencingColumnNameList(pColName);
}
break;
case ELM_CONSTRAINT_UNIQUE_ELEM :
{
ComASSERT(pColAttr->castToElemDDLConstraintUnique() NEQ NULL);
ComASSERT(pColAttr->castToElemDDLConstraintUnique()->getConstraintKind()
EQU ElemDDLConstraint::COLUMN_CONSTRAINT_DEF);
columnConstraintArray_.insert(pColAttr->castToElemDDLConstraint());
//
// The column name is not specified in the column unique
// constraint definition. To make the user (caller) to access
// to this information easier, creates a parse node containing
// the column name.
//
ElemDDLConstraintUnique * pColUniqueConstraint =
pColAttr->castToElemDDLConstraintUnique();
ComASSERT(pColUniqueConstraint->getColumnRefList() EQU NULL);
ElemDDLColRef * pColRef = new(PARSERHEAP())
ElemDDLColRef(getColumnName(),
COM_ASCENDING_ORDER,
PARSERHEAP());
pColUniqueConstraint->setColumnRefList(pColRef);
}
break;
case ELM_LOBATTRS:
{
ComASSERT( NULL NEQ pColAttr->castToElemDDLLobAttrs())
if(TRUE == isLobAttrsSpec_)
{
// Duplicate LOB attrs in column definition.
*SqlParser_Diags << DgSqlCode(-3052)
<< DgString0("LOB")
<< DgColumnName(ToAnsiIdentifier(getColumnName()));
}
isLobAttrsSpec_ = TRUE;
lobStorage_ = pColAttr->castToElemDDLLobAttrs()->getLobStorage();
}
break;
case ELM_SEABASE_SERIALIZED:
{
ComASSERT( NULL NEQ pColAttr->castToElemDDLSeabaseSerialized())
if(TRUE == isSeabaseSerializedSpec_)
{
// Duplicate SERIALIZED attrs in column definition.
*SqlParser_Diags << DgSqlCode(-3052)
<< DgString0("SERIALIZED")
<< DgColumnName(ToAnsiIdentifier(getColumnName()));
}
isSeabaseSerializedSpec_ = TRUE;
seabaseSerialized_ = pColAttr->castToElemDDLSeabaseSerialized()->serialized();
}
break;
case ELM_COL_DEFAULT_ELEM:
{
ComASSERT( NULL NEQ pColAttr->castToElemDDLColDefault());
if(TRUE == isColDefaultSpec_)
{
// Duplicate DEFAULT attrs in column definition.
*SqlParser_Diags << DgSqlCode(-3052)
<< DgString0("DEFAULT")
<< DgColumnName(ToAnsiIdentifier(getColumnName()));
}
isColDefaultSpec_ = TRUE;
setDefaultAttribute(pColAttr->castToElemDDLColDefault());
}
break;
default :
ABORT("internal logic error");
break;
} // switch
}
ExprNode *
ElemDDLMVFileAttrClause::getChild(Lng32 index)
{
ComASSERT(index >= 0 AND index < getArity());
return children_[index];
}
// constructor
ElemDDLConstraintRI::ElemDDLConstraintRI(
ElemDDLNode * pReferencedTableAndColumns,
ComRCMatchOption matchType,
ElemDDLNode * pReferentialTriggeredActions,
CollHeap * heap)
: ElemDDLConstraint(heap, ELM_CONSTRAINT_REFERENTIAL_INTEGRITY_ELEM),
matchType_(matchType),
isDeleteRuleSpec_(FALSE),
deleteRule_(COM_NO_ACTION_DELETE_RULE),
isUpdateRuleSpec_(FALSE),
updateRule_(COM_NO_ACTION_UPDATE_RULE),
referencingColumnNameArray_(heap),
referencedColumnNameArray_(heap)
{
setChild(INDEX_REFERENCING_COLUMN_NAME_LIST, NULL);
setChild(INDEX_REFERENCED_TABLE_AND_COLUMNS, pReferencedTableAndColumns);
setChild(INDEX_REFERENTIAL_TRIGGERED_ACTIONS, pReferentialTriggeredActions);
//
// Note that at the point this parse node is contructed, the information
// regarding the referencing column name list (in the FOREIGN KEY phrase)
// has not been collected yet.
//
//
// referenced table name
//
ComASSERT(pReferencedTableAndColumns);
ElemDDLReferences * pReferences = pReferencedTableAndColumns
->castToElemDDLReferences();
ComASSERT(pReferences);
//
// referenced column name list (if any)
//
ElemDDLNode * pReferencedColumns = pReferences->getReferencedColumns();
if (pReferencedColumns)
{
for (CollIndex index = 0; index < pReferencedColumns->entries(); index++)
{
referencedColumnNameArray_.insert((*pReferencedColumns)[index]
->castToElemDDLColName());
}
}
//
// referential triggered actions
//
if (pReferentialTriggeredActions)
{
for (CollIndex i = 0; i < pReferentialTriggeredActions->entries(); i++)
{
ComASSERT((*pReferentialTriggeredActions)[i]);
setReferentialTriggeredAction((*pReferentialTriggeredActions)[i]
->castToElemDDLRefTrigAct());
}
}
} // ElemDDLConstraintRI::ElemDDLConstraintRI()
ExprNode *
ElemDDLLike::getChild(Lng32 index)
{
ComASSERT(index >= 0 AND index < MAX_ELEM_DDL_LIKE_ARITY);
return pLikeOptions_;
}
// method for building text
//virtual
NAString ElemDDLPartitionClause::getSyntax() const
{
NAString syntax = "";
switch(partitionType_)
{
case COM_SYSTEM_PARTITIONING:
// this is the default - no syntax
break;
case COM_RANGE_PARTITIONING:
syntax += "RANGE ";
break;
case COM_HASH_V1_PARTITIONING:
syntax += "HASH ";
break;
case COM_HASH_V2_PARTITIONING:
syntax += "HASH2 ";
break;
default:
ComASSERT(FALSE);
}
syntax += "PARTITION ";
ElemDDLNode * pElemDDL = getPartitionByOption();
if(NULL != pElemDDL)
{
ElemDDLPartitionByColumnList * pPartitionByColList =
pElemDDL->castToElemDDLPartitionByColumnList();
ComASSERT(NULL != pPartitionByColList);
syntax += "BY ";
syntax += "(";
syntax += pPartitionByColList->getSyntax();
syntax += ") ";
}
pElemDDL = getPartitionDefBody();
if(NULL != pElemDDL)
{
// pElemDDL dynamic type returned from the parser can be either an
// ElemDDLPartitionList or an ElemDDLPartitionRange
ElemDDLPartitionList * pPartitionList =
pElemDDL->castToElemDDLPartitionList();
ElemDDLPartitionRange *pRange = pElemDDL->castToElemDDLPartitionRange();
//++ MV
syntax += "(";
if(NULL != pPartitionList)
{
syntax += pPartitionList->getSyntax();
}
else
{
ComASSERT(NULL != pRange);
syntax += pRange->getSyntax();
}
syntax += ") ";
//-- MV
}
return syntax;
} // getSyntax()
