/// <summary>
/// Determine whether procedure should be ignored due to certain data types
/// </summary>
/// <param name="reasonMsg"></param>
/// <returns></returns>
public Boolean IsIgnoredDueToOracleArgumentTypes(out String reasonMsg)
{
reasonMsg = "";
String unimplemntedType = "";
if (HasArgumentOfOracleTypeAssocArrayOfUnimplementedType(out unimplemntedType))
{
reasonMsg = ".NET cannot send/receive an associative array of a " + unimplemntedType;
return(true);
}
else if (HasInArgumentOfOracleTypeRefCursor())
{
reasonMsg = ".NET cannot send/receive a " + Orcl.REF_CURSOR;
return(true);
}
else
{
foreach (String oraType in Translater.OracleTypesIgnored)
{
if (UsesOracleType(oraType, !oraType.Equals(Orcl.RECORD)))
{
Translater.IsOracleTypeIgnored(oraType, out reasonMsg); // get reason
return(true);
}
}
}
return(false);
}
/// <summary>
/// Given all arguments for package's procs, load all package specific types (e.g., a record) into memory
/// </summary>
/// <param name="arguments"></param>
private void LoadPackageRecordTypes <T_PackageRecord, T_Field, T_Argument>(List <IArgument> arguments)
where T_PackageRecord : class, IPackageRecord, new()
where T_Field : class, IField, new()
where T_Argument : class, IArgument, new()
{
foreach (IArgument arg in arguments)
{
switch (arg.DataType)
{
case Orcl.RECORD:
if (arg.DataLevel == 0)
{
continue; // ignore straight record type (without cursor)
}
// send the record argument and a list of all subsequent arguments
LoadRecordType <T_PackageRecord, T_Field, T_Argument>(arg, arguments.GetRange(arguments.IndexOf(arg) + 1, arguments.Count - arguments.IndexOf(arg) - 1), null);
continue;
case Orcl.ASSOCIATITVE_ARRAY:
// For an associative array of a record, we will need to create a class for the record.
if (arguments[arguments.IndexOf(arg) + 1].DataType == Orcl.RECORD)
{
// First get type of the associated array by converting to C#. This will be a list of a class. We need the class name
// in order to to load into our Oracle record types.
String assocArrayCSharpType = Translater.ConvertOracleArgTypeToCSharpType(arg, false);
// Send the arg following the assoc array arg since it holds the record, a list of all args following the record arg,
// and the C# name of the record parsed out of the assoc array C# type.
LoadRecordType <T_PackageRecord, T_Field, T_Argument>(arguments[arguments.IndexOf(arg) + 1],
arguments.GetRange(arguments.IndexOf(arg) + 2, arguments.Count - arguments.IndexOf(arg) - 2),
CSharp.ExtractSubtypeFromGenericCollectionType(assocArrayCSharpType, false));
}
continue;
default:
continue;
}
}
return;
}
/// <summary>
/// Given a record type argument, extract and store the record type and its fields (recurse if necessary)
/// </summary>
/// <param name="recordArg">Argument with record</param>
/// <param name="args">List of arguments following record argument</param>
private void LoadRecordType <T_PackageRecord, T_Field, T_Argument>(IArgument recordArg, List <IArgument> args, String cSharpType)
where T_PackageRecord : class, IPackageRecord, new()
where T_Field : class, IField, new()
where T_Argument : class, IArgument, new()
{
if (recordArg.DataType != Orcl.RECORD)
{
throw new Exception("Argument sent to LoadRecordType() that is not a PL/SQL RECORD");
}
// happens for type OBJECT, TABLE, VARRAY or UNDEFINED
if ((recordArg.TypeName == null && recordArg.TypeSubname != null) || (recordArg.TypeName != null && recordArg.TypeSubname == null))
{
return;
}
if (cSharpType == null)
{
cSharpType = Translater.ConvertOracleArgTypeToCSharpType(recordArg, false);
}
// if the record type has already been stored, do not proceeed
if (PackageRecordTypes.Any(r => (r.SubName ?? "") == (recordArg.TypeSubname ?? "") &&
(r.Name ?? "") == (recordArg.TypeName ?? "") &&
(r.Owner ?? "") == (recordArg.TypeOwner ?? "") &&
(r.PackageName ?? "") == (recordArg.PackageName ?? "")))
{
return;
}
// begin creation of record type
IPackageRecord newRec = new T_PackageRecord();
newRec.PackageName = recordArg.PackageName; // package containing argument
newRec.Name = recordArg.TypeName; // package containing *record type*
newRec.SubName = recordArg.TypeSubname; // name of record type if outside argument's package
newRec.CSharpType = cSharpType;
newRec.Owner = recordArg.TypeOwner;
newRec.Attributes = new List <IEntityAttribute>();
int recordDataLevel = recordArg.DataLevel;
// loop the args to find this record's fields or a nested record type
int columnPosition = 0;
foreach (IArgument arg in args)
{
if (arg.DataLevel == recordDataLevel + 1) // found a record field
// each of these fields are to be added to the record
{
IField f = new T_Field();
f.Name = arg.ArgumentName;
// convert to C# now - this should to be adjusted so it's done later
f.CSharpType = Translater.ConvertOracleArgTypeToCSharpType(arg, false);
// set the containing class from the package name
if (!String.IsNullOrEmpty(arg.TypeName) && !arg.TypeName.Equals(arg.PackageName))
{
if (!Parameter.Instance.IsDuplicatePackageRecordOriginatingOutsideFilterAndSchema
// owned by another schema or owned by package that was filtered out
&& (!(arg.Owner ?? "").Equals(arg.TypeOwner)
// || !_packages.Exists(p => p.PackageName.Equals(arg.TypeName)) ) ) {
|| !Packages.Any(p => p.PackageName.Equals(arg.TypeName))))
{
f.ContainerClassName = Translater.ConvertOracleNameToCSharpName(arg.TypeName, false);
}
if (!(arg.TypeName ?? "").Equals(arg.PackageName)
// && _packages.Exists(p => p.PackageName.Equals(arg.TypeName)) // package of origin of record being created
&& Packages.Any(p => p.PackageName.Equals(arg.TypeName)) && // package of origin of record being created
PackageRecordTypes.Exists(r => r.PackageName.Equals(arg.TypeName) && r.SubName.Equals(arg.TypeSubname)))
{
f.ContainerClassName = Translater.ConvertOracleNameToCSharpName(arg.TypeName, false);
}
}
f.AttrType = arg.DataType;
f.Length = arg.DataLength;
f.Precision = arg.DataPrecision;
f.Scale = arg.DataScale;
f.MapPosition = columnPosition++;
newRec.Attributes.Add(f);
}
else if (arg.DataLevel == recordDataLevel + 2) // found a lower level field, so skip
{
continue;
}
else if (arg.DataLevel <= recordDataLevel) // we are past the last record field, we are done
{
break;
}
// if field is nested record, recurse into it
if (arg.DataType == Orcl.RECORD)
{
LoadRecordType <T_PackageRecord, T_Field, T_Argument>(arg, args.GetRange(args.IndexOf(arg) + 1, args.Count - args.IndexOf(arg) - 1), null);
}
}
// newRec.Fields.Sort();
PackageRecordTypes.Add(newRec);
return;
}
