convert SQLNodeType to scoped enum

Change-Id: I622e55622d38e6017993c8bc52625c85d0f74d74

4 files changed, 49 insertions, 49 deletions

diff --git a/dbaccess/source/core/api/RowSetCache.cxx b/dbaccess/source/core/api/RowSetCache.cxx
index 81316864ea04..69d388c22347 100644
--- a/dbaccess/source/core/api/RowSetCache.cxx
+++ b/dbaccess/source/core/api/RowSetCache.cxx
@@ -1541,7 +1541,7 @@ bool ORowSetCache::checkInnerJoin(const ::connectivity::OSQLParseNode *pNode,con
         OSL_ENSURE(pNode->count() == 3,"checkInnerJoin: Fehler im Parse Tree");
         if (!(SQL_ISRULE(pNode->getChild(0),column_ref) &&
                 SQL_ISRULE(pNode->getChild(2),column_ref) &&
-                pNode->getChild(1)->getNodeType() == SQL_NODE_EQUAL))
+                pNode->getChild(1)->getNodeType() == SQLNodeType::Equal))
         {
             bOk = false;
         }
diff --git a/dbaccess/source/core/api/SingleSelectQueryComposer.cxx b/dbaccess/source/core/api/SingleSelectQueryComposer.cxx
index 7a667400a66a..4da4c7068bc1 100644
--- a/dbaccess/source/core/api/SingleSelectQueryComposer.cxx
+++ b/dbaccess/source/core/api/SingleSelectQueryComposer.cxx
@@ -1089,22 +1089,22 @@ sal_Int32 OSingleSelectQueryComposer::getPredicateType(OSQLParseNode * _pPredica
     sal_Int32 nPredicate = SQLFilterOperator::EQUAL;
     switch (_pPredicate->getNodeType())
     {
-        case SQL_NODE_EQUAL:
+        case SQLNodeType::Equal:
             nPredicate = SQLFilterOperator::EQUAL;
             break;
-        case SQL_NODE_NOTEQUAL:
+        case SQLNodeType::NotEqual:
             nPredicate = SQLFilterOperator::NOT_EQUAL;
             break;
-        case SQL_NODE_LESS:
+        case SQLNodeType::Less:
             nPredicate = SQLFilterOperator::LESS;
             break;
-        case SQL_NODE_LESSEQ:
+        case SQLNodeType::LessEq:
             nPredicate = SQLFilterOperator::LESS_EQUAL;
             break;
-        case SQL_NODE_GREAT:
+        case SQLNodeType::Great:
             nPredicate = SQLFilterOperator::GREATER;
             break;
-        case SQL_NODE_GREATEQ:
+        case SQLNodeType::GreatEq:
             nPredicate = SQLFilterOperator::GREATER_EQUAL;
             break;
         default:
@@ -1130,7 +1130,7 @@ bool OSingleSelectQueryComposer::setComparsionPredicate(OSQLParseNode * pConditi
 
             aItem.Handle = getPredicateType(pCondition->getChild(i));
             // don't display the equal
-            if (pCondition->getChild(i)->getNodeType() == SQL_NODE_EQUAL)
+            if (pCondition->getChild(i)->getNodeType() == SQLNodeType::Equal)
                 i++;
 
             // go forward
@@ -1145,34 +1145,34 @@ bool OSingleSelectQueryComposer::setComparsionPredicate(OSQLParseNode * pConditi
             sal_Int32 i = pCondition->count() - 2;
             switch (pCondition->getChild(i)->getNodeType())
             {
-                case SQL_NODE_EQUAL:
+                case SQLNodeType::Equal:
                     // don't display the equal
                     i--;
                     aItem.Handle = SQLFilterOperator::EQUAL;
                     break;
-                case SQL_NODE_NOTEQUAL:
+                case SQLNodeType::NotEqual:
                     i--;
                     aItem.Handle = SQLFilterOperator::NOT_EQUAL;
                     break;
-                case SQL_NODE_LESS:
+                case SQLNodeType::Less:
                     // take the opposite as we change the order
                     i--;
                     aValue = ">=";
                     aItem.Handle = SQLFilterOperator::GREATER_EQUAL;
                     break;
-                case SQL_NODE_LESSEQ:
+                case SQLNodeType::LessEq:
                     // take the opposite as we change the order
                     i--;
                     aValue = ">";
                     aItem.Handle = SQLFilterOperator::GREATER;
                     break;
-                case SQL_NODE_GREAT:
+                case SQLNodeType::Great:
                     // take the opposite as we change the order
                     i--;
                     aValue = "<=";
                     aItem.Handle = SQLFilterOperator::LESS_EQUAL;
                     break;
-                case SQL_NODE_GREATEQ:
+                case SQLNodeType::GreatEq:
                     // take the opposite as we change the order
                     i--;
                     aValue = "<";
diff --git a/dbaccess/source/ui/querydesign/QueryDesignView.cxx b/dbaccess/source/ui/querydesign/QueryDesignView.cxx
index ba937e1f6c62..00d4b662fab3 100644
--- a/dbaccess/source/ui/querydesign/QueryDesignView.cxx
+++ b/dbaccess/source/ui/querydesign/QueryDesignView.cxx
@@ -570,7 +570,7 @@ namespace
             OSL_ENSURE(pNode->count() == 3,"OQueryDesignView::InsertJoinConnection: Error in Parse Tree");
             if (!(SQL_ISRULE(pNode->getChild(0),column_ref) &&
                   SQL_ISRULE(pNode->getChild(2),column_ref) &&
-                   pNode->getChild(1)->getNodeType() == SQL_NODE_EQUAL))
+                   pNode->getChild(1)->getNodeType() == SQLNodeType::Equal))
             {
                 OUString sError(ModuleRes(STR_QRY_JOIN_COLUMN_COMPARE));
                 _pView->getController().appendError( sError );
@@ -1630,7 +1630,7 @@ namespace
                 sal_uInt32 i=1;
 
                 // don't display the equal
-                if (pCondition->getChild(i)->getNodeType() == SQL_NODE_EQUAL)
+                if (pCondition->getChild(i)->getNodeType() == SQLNodeType::Equal)
                     i++;
 
                 // Bedingung parsen
@@ -1647,26 +1647,26 @@ namespace
                 sal_Int32 i = static_cast<sal_Int32>(pCondition->count() - 2);
                 switch (pCondition->getChild(i)->getNodeType())
                 {
-                    case SQL_NODE_EQUAL:
+                    case SQLNodeType::Equal:
                         // don't display the equal
                         i--;
                         break;
-                    case SQL_NODE_LESS:
+                    case SQLNodeType::Less:
                         // take the opposite as we change the order
                         i--;
                         aCondition += ">";
                         break;
-                    case SQL_NODE_LESSEQ:
+                    case SQLNodeType::LessEq:
                         // take the opposite as we change the order
                         i--;
                         aCondition += ">=";
                         break;
-                    case SQL_NODE_GREAT:
+                    case SQLNodeType::Great:
                         // take the opposite as we change the order
                         i--;
                         aCondition += "<";
                         break;
-                    case SQL_NODE_GREATEQ:
+                    case SQLNodeType::GreatEq:
                         // take the opposite as we change the order
                         i--;
                         aCondition += "<=";
@@ -3256,38 +3256,38 @@ void OQueryDesignView::fillFunctionInfo(  const ::connectivity::OSQLParseNode* p
     sal_Int32 nDataType = DataType::DOUBLE;
     switch(pNode->getNodeType())
     {
-    case SQL_NODE_CONCAT:
-    case SQL_NODE_STRING:
+    case SQLNodeType::Concat:
+    case SQLNodeType::String:
         nDataType = DataType::VARCHAR;
         break;
-    case SQL_NODE_INTNUM:
+    case SQLNodeType::IntNum:
         nDataType = DataType::INTEGER;
         break;
-    case SQL_NODE_APPROXNUM:
+    case SQLNodeType::ApproxNum:
         nDataType = DataType::DOUBLE;
         break;
-    case SQL_NODE_DATE:
-    case SQL_NODE_ACCESS_DATE:
+    case SQLNodeType::Date:
+    case SQLNodeType::AccessDate:
         nDataType = DataType::TIMESTAMP;
         break;
-    case SQL_NODE_COMPARISON:
-    case SQL_NODE_EQUAL:
-    case SQL_NODE_LESS:
-    case SQL_NODE_GREAT:
-    case SQL_NODE_LESSEQ:
-    case SQL_NODE_GREATEQ:
-    case SQL_NODE_NOTEQUAL:
+    case SQLNodeType::Comparison:
+    case SQLNodeType::Equal:
+    case SQLNodeType::Less:
+    case SQLNodeType::Great:
+    case SQLNodeType::LessEq:
+    case SQLNodeType::GreatEq:
+    case SQLNodeType::NotEqual:
         nDataType = DataType::BOOLEAN;
         break;
-    case SQL_NODE_NAME:
-    case SQL_NODE_LISTRULE:
-    case SQL_NODE_COMMALISTRULE:
-    case SQL_NODE_KEYWORD:
-    case SQL_NODE_AMMSC: //??
-    case SQL_NODE_PUNCTUATION:
+    case SQLNodeType::Name:
+    case SQLNodeType::ListRule:
+    case SQLNodeType::CommaListRule:
+    case SQLNodeType::Keyword:
+    case SQLNodeType::AMMSC: //??
+    case SQLNodeType::Punctuation:
         OSL_FAIL("Unexpected SQL Node Type");
         break;
-    case SQL_NODE_RULE:
+    case SQLNodeType::Rule:
         switch(pNode->getKnownRuleID())
         {
         case OSQLParseNode::select_statement:
diff --git a/dbaccess/source/ui/querydesign/querycontroller.cxx b/dbaccess/source/ui/querydesign/querycontroller.cxx
index 9374ef3de951..05b8bde2c3ba 100644
--- a/dbaccess/source/ui/querydesign/querycontroller.cxx
+++ b/dbaccess/source/ui/querydesign/querycontroller.cxx
@@ -166,45 +166,45 @@ namespace dbaui
                 switch (_pNode->getNodeType())
                 {
 
-                case SQL_NODE_KEYWORD:
+                case SQLNodeType::Keyword:
                     {
                         rString += "SQL_KEYWORD:";
                         OString sT = OSQLParser::TokenIDToStr(_pNode->getTokenID());
                         rString += OStringToOUString(sT, RTL_TEXTENCODING_UTF8);
                      break;}
 
-                case SQL_NODE_COMPARISON:
+                case SQLNodeType::Comparison:
                     {
                         rString += "SQL_COMPARISON:" + _pNode->getTokenValue(); // append Nodevalue
                             // and start new line
                         break;}
 
-                case SQL_NODE_NAME:
+                case SQLNodeType::Name:
                     {
                         rString += "SQL_NAME:\"" + _pNode->getTokenValue() + "\"";
                         break;}
 
-                case SQL_NODE_STRING:
+                case SQLNodeType::String:
                     {
                         rString += "SQL_STRING:'" + _pNode->getTokenValue();
                         break;}
 
-                case SQL_NODE_INTNUM:
+                case SQLNodeType::IntNum:
                     {
                         rString += "SQL_INTNUM:" + _pNode->getTokenValue();
                         break;}
 
-                case SQL_NODE_APPROXNUM:
+                case SQLNodeType::ApproxNum:
                     {
                         rString += "SQL_APPROXNUM:" + _pNode->getTokenValue();
                         break;}
 
-                case SQL_NODE_PUNCTUATION:
+                case SQLNodeType::Punctuation:
                     {
                         rString += "SQL_PUNCTUATION:" + _pNode->getTokenValue(); // append Nodevalue
                         break;}
 
-                case SQL_NODE_AMMSC:
+                case SQLNodeType::AMMSC:
                     {
                         rString += "SQL_AMMSC:" + _pNode->getTokenValue(); // append Nodevalue
                         break;}