public static PLSQLSpec ValidateParsedSpec(PLSQLSpecParsed parsedSpec)
{
PLSQLSpec spec = null;
if (parsedSpec != null)
{
spec = new PLSQLSpec();
// Get the package name
spec.PackageName = parsedSpec.PackageName;
// Get the filename (if it exists)
spec.FileNameParsed = parsedSpec.FileNameParsed;
// Get the length of the read package
spec.PackageLength = parsedSpec.PackageLength;
// Get the hash of the read package
spec.PackageHash = parsedSpec.PackageHash;
// Loop through the parsed procedures.
foreach (PLSQLSpecParsedProcedure procedure in parsedSpec.Procedures)
{
// Create a new procedure
PLSQLProcedure newProcedure = new PLSQLProcedure();
// Get name
newProcedure.Name = procedure.Name;
// Set status and errortext if parse error
if (procedure.HasParseError)
{
newProcedure.Status = ProcedureStatus.ParseError;
newProcedure.SetErrorText(procedure.ParseErrorText, string.Empty);
}
// Get if function
if (procedure.IsFunction)
{
newProcedure.IsFunction = true;
switch (procedure.FunctionReturnType)
{
case ParseFunctionReturnType.DataType:
newProcedure.FunctionReturnType = FunctionReturnType.DataType;
switch (procedure.FunctionReturnTypeData.DataType)
{
case ParseFunctionReturnDBDataType.Boolean:
newProcedure.FunctionReturnTypeDataType_DataType = FunctionReturnDBDataType.Boolean;
break;
case ParseFunctionReturnDBDataType.Date:
newProcedure.FunctionReturnTypeDataType_DataType = FunctionReturnDBDataType.Date;
break;
case ParseFunctionReturnDBDataType.Number:
newProcedure.FunctionReturnTypeDataType_DataType = FunctionReturnDBDataType.Number;
break;
case ParseFunctionReturnDBDataType.Varchar:
newProcedure.FunctionReturnTypeDataType_DataType = FunctionReturnDBDataType.Varchar;
break;
case ParseFunctionReturnDBDataType.Varchar2:
newProcedure.FunctionReturnTypeDataType_DataType = FunctionReturnDBDataType.Varchar2;
break;
default:
newProcedure.FunctionReturnTypeDataType_DataType = FunctionReturnDBDataType.Invalid;
break;
}
// Check if we have catched the datatype. If we have an invalid datatype this is not supported.
if (newProcedure.Status == ProcedureStatus.Valid &&
newProcedure.FunctionReturnTypeDataType_DataType == FunctionReturnDBDataType.Invalid)
{
newProcedure.Status = ProcedureStatus.NotSupported;
newProcedure.SetErrorText(PLSQLSupportedSpecTexts.ProcedureFunctionReturnTypeNotSupported, string.Empty);
}
break;
case ParseFunctionReturnType.TableColumn:
newProcedure.FunctionReturnType = FunctionReturnType.TableColumn;
newProcedure.FunctionReturnTypeTableColumn_Table = procedure.FunctionReturnTypeTableColumn_Table;
newProcedure.FunctionReturnTypeTableColumn_Column = procedure.FunctionReturnTypeTableColumn_Column;
break;
}
}
else
{
newProcedure.IsFunction = false;
}
// Variable for breaking the loop below.
bool doBreak = false;
// Loop through all parameters
foreach (PLSQLSpecParsedProcedureParameter parameter in procedure.Parameters)
{
// Create the new parameter
PLSQLProcedureParameter newParam = new PLSQLProcedureParameter();
// Fetch name
newParam.Name = parameter.Name;
// Fetch if mandatory
newParam.IsMandatory = parameter.IsMandatory;
// Check parametertype
switch (parameter.ParameterType)
{
case ParseParameterType.DataType:
// Set the type
newParam.ParameterType = ParameterType.DataType;
// What datatypes do we support from the parsed ones.
switch (parameter.ParameterTypeData.DataType)
{
case ParseParameterDBDataType.Boolean:
newParam.ParameterTypeDataType_DataType = ParameterDBDataType.Boolean;
break;
case ParseParameterDBDataType.Number:
newParam.ParameterTypeDataType_DataType = ParameterDBDataType.Number;
break;
case ParseParameterDBDataType.Varchar2:
newParam.ParameterTypeDataType_DataType = ParameterDBDataType.Varchar2;
break;
case ParseParameterDBDataType.Varchar:
newParam.ParameterTypeDataType_DataType = ParameterDBDataType.Varchar;
break;
case ParseParameterDBDataType.Date:
newParam.ParameterTypeDataType_DataType = ParameterDBDataType.Date;
break;
case ParseParameterDBDataType.Ref_Cur:
newParam.ParameterTypeDataType_DataType = ParameterDBDataType.Ref_Cur;
newProcedure.IsContainingRefCursor = true;
// Check that this is an out parameter and that there are no more out
// parameters exept ALMID_O and that this parameter is the last one
if (parameter.Direction != ParseParameterDirection.Out ||
procedure.Parameters.Where(param => param.Name != newParam.Name && param.Name != "ALMID_O" && ((param.Direction == ParseParameterDirection.InOut) || (param.Direction == ParseParameterDirection.Out))).Count() > 0)
{
newProcedure.Status = ProcedureStatus.NotSupported;
newProcedure.SetErrorText(PLSQLSupportedSpecTexts.ProcedureRefCursorVariantNotSupported, parameter.Name);
// Don't handle more parameters for this procedure.
doBreak = true;
break;
}
else if (procedure.IsFunction)
{
newProcedure.Status = ProcedureStatus.NotSupported;
newProcedure.SetErrorText(PLSQLSupportedSpecTexts.ProcedureRefCursorFunctionNotSupported, parameter.Name);
// Don't handle more parameters for this procedure.
doBreak = true;
break;
}
else if (procedure.Parameters.Last().Name != newParam.Name && procedure.Parameters.Last().Name != "ALMID_O" || (procedure.Parameters.Last().Name == "ALMID_O" && procedure.Parameters[procedure.Parameters.Count - 2].Name != newParam.Name))
{
newProcedure.Status = ProcedureStatus.NotSupported;
newProcedure.SetErrorText(PLSQLSupportedSpecTexts.ProcedureRefCursorParameterOrderNotSupported, parameter.Name);
// Don't handle more parameters for this procedure.
doBreak = true;
break;
}
break;
default:
// If the original datatype is Invalid then there will be
// a parse error anyway so just copy the Invalid type.
newParam.ParameterTypeDataType_DataType = ParameterDBDataType.Invalid;
break;
}
// Check if we have catched the datatype. If we have an invalid datatype this is not supported.
if (newProcedure.Status == ProcedureStatus.Valid &&
newParam.ParameterTypeDataType_DataType == ParameterDBDataType.Invalid)
{
newProcedure.Status = ProcedureStatus.NotSupported;
newProcedure.SetErrorText(PLSQLSupportedSpecTexts.ProcedureParameterTypeNotSupported, parameter.Name);
}
break;
case ParseParameterType.TableColumn:
// Set the parameter type
newParam.ParameterType = ParameterType.TableColumn;
newParam.ParameterTypeTableColumn_Table = parameter.ParseParameterTypeTableColumn_Table;
newParam.ParameterTypeTableColumn_Column = parameter.ParseParameterTypeTableColumn_Column;
break;
case ParseParameterType.TableRow:
// Parameters with types like TABLENAME%rowtype are not supported.
newProcedure.Status = ProcedureStatus.NotSupported;
newProcedure.SetErrorText(PLSQLSupportedSpecTexts.ProcedureParameterTypeTablerowNotSupported, parameter.Name);
// Set the parameter type
newParam.ParameterType = ParameterType.NotSupported;
// Don't handle more parameters for this procedure.
doBreak = true;
break;
case ParseParameterType.PackageDataType:
// Parameters with types like PACKAGE.PACKAGEDATATYPE are not supported.
newProcedure.Status = ProcedureStatus.NotSupported;
newProcedure.SetErrorText(PLSQLSupportedSpecTexts.ProcedureParameterTypePackageDataTypeNotSupported, parameter.Name);
// Set the parameter type
newParam.ParameterType = ParameterType.NotSupported;
// Don't handle more parameters for this procedure.
doBreak = true;
break;
default:
// Unknown parameter type
newProcedure.Status = ProcedureStatus.NotSupported;
newProcedure.SetErrorText(PLSQLSupportedSpecTexts.ProcedureParameterTypeUnknown, parameter.Name);
// Set the parameter type
newParam.ParameterType = ParameterType.NotSupported;
// Don't handle more parameters for this procedure.
doBreak = true;
break;
}
// Translate directions
switch (parameter.Direction)
{
case ParseParameterDirection.In:
newParam.Direction = ParameterDirection.In;
break;
case ParseParameterDirection.InOut:
newParam.Direction = ParameterDirection.InOut;
break;
case ParseParameterDirection.Out:
newParam.Direction = ParameterDirection.Out;
break;
}
// Add the parameter to the parameterlist
newProcedure.Parameters.Add(newParam);
// Don't handle more parameters if this variable is set to true.
if (doBreak)
{
break;
}
}
// Add the procedure to the procedure list
spec.Procedures.Add(newProcedure);
}
}
return(spec);
}
public static string RecreateProcedure(PLSQLProcedure procedure)
{
string procString = string.Empty;
if (procedure.Status == ProcedureStatus.Valid)
{
procString += procedure.IsFunction ? "function " : "procedure ";
procString += procedure.Name;
if (procedure.Parameters.Count > 0)
{
// The current length of the procString is how many spaces
// that should be added for each new parameter.
int tabLength = procString.Length;
procString += "(";
// First check length in total
int paraNameLen = 0;
for (int i = 0; i < procedure.Parameters.Count; i++)
{
int len;
PLSQLProcedureParameter param = procedure.Parameters[i];
len = param.Name.Length + 1;
if (param.IsMandatory)
{
len += 15 + 1; // "/* Mandatory */ "
}
if (param.Direction == ParameterDirection.InOut)
{
len += 6 + 1; // "in out "
}
else if (param.Direction == ParameterDirection.Out)
{
len += 3 + 1; // "out "
}
paraNameLen = Math.Max(paraNameLen, len);
}
for (int i = 0; i < procedure.Parameters.Count; i++)
{
PLSQLProcedureParameter param = procedure.Parameters[i];
// Pad to the right the amount of spaces as the tabLength and add a comma.
if (i != 0)
{
procString += "".PadLeft(tabLength, ' ') + ",";
}
string tmpString = string.Empty;
tmpString += param.IsMandatory ? "/* Mandatory */ " : string.Empty;
switch (param.Direction)
{
case ParameterDirection.InOut:
tmpString += "in out ";
break;
case ParameterDirection.Out:
tmpString += "out ";
break;
}
tmpString = param.Name + "".PadLeft(paraNameLen - tmpString.Length - param.Name.Length, ' ') + tmpString;
procString += tmpString;
switch (param.ParameterType)
{
case ParameterType.DataType:
switch (param.ParameterTypeDataType_DataType)
{
case ParameterDBDataType.Boolean:
procString += "boolean";
break;
case ParameterDBDataType.Date:
procString += "date";
break;
case ParameterDBDataType.Number:
procString += "number";
break;
case ParameterDBDataType.Varchar:
procString += "varchar";
break;
case ParameterDBDataType.Varchar2:
procString += "varchar2";
break;
case ParameterDBDataType.Ref_Cur:
procString += "ref_cur";
break;
default:
procString += "<NotDefined>";
break;
}
break;
case ParameterType.TableColumn:
procString += param.ParameterTypeTableColumn_Table + "." + param.ParameterTypeTableColumn_Column + "%type";
break;
}
if (i != (procedure.Parameters.Count - 1))
{
procString += Environment.NewLine;
}
}
procString += ")";
}
if (procedure.IsFunction)
{
procString += Environment.NewLine + " return ";
switch (procedure.FunctionReturnType)
{
case FunctionReturnType.DataType:
switch (procedure.FunctionReturnTypeDataType_DataType)
{
case FunctionReturnDBDataType.Boolean:
procString += "boolean";
break;
case FunctionReturnDBDataType.Number:
procString += "number";
break;
case FunctionReturnDBDataType.Varchar2:
procString += "varchar2";
break;
case FunctionReturnDBDataType.Varchar:
procString += "varchar";
break;
case FunctionReturnDBDataType.Date:
procString += "date";
break;
default:
procString += "<NotDefined>";
break;
}
break;
case FunctionReturnType.TableColumn:
procString += procedure.FunctionReturnTypeTableColumn_Table + "." + procedure.FunctionReturnTypeTableColumn_Column + "%type";
break;
}
procString += ";";
}
else
{
procString += ";";
}
}
return(procString);
}