/// <summary>
/// Register operation.
/// </summary>
/// <typeparam name="TInput">Type of input.</typeparam>
/// <param name="operationName">Operation Name.</param>
/// <param name="returnDataType">Return Data type.</param>
/// <param name="storedProcedureName">Stored procedure name.</param>
/// <returns>object where the given operation is registered.</returns>
/// <param name="primitiveSpParameterName">Name of stored procedure parameter which is primitive.</param>
public RuntimeMapInfo RegisterOperation <TInput>(
string operationName,
string storedProcedureName = null,
ReturnDataType returnDataType = ReturnDataType.NoReturnValue,
string primitiveSpParameterName = null)
{
return(this.RegisterOperation(
operationName,
typeof(TInput),
returnDataType,
storedProcedureName,
primitiveSpParameterName));
}
/// <summary>
/// Registers operation for map info.
/// </summary>
/// <param name="operationName">Operation name.</param>
/// <param name="inputType">Input type.</param>
/// <param name="returnDataType">Return data type.</param>
/// <param name="storedProcedureName">Stored Procedure name.</param>
/// <param name="primitiveSpParameterName">Name of stored procedure parameter which is primitive.</param>
/// <returns>object where the given operation is registered.</returns>
public RuntimeMapInfo RegisterOperation(
string operationName,
Type inputType,
ReturnDataType returnDataType = ReturnDataType.NoReturnValue,
string storedProcedureName = null,
string primitiveSpParameterName = null)
{
if (string.IsNullOrEmpty(operationName))
{
throw new ArgumentException("Operation name cannot be empty.");
}
if (this._descriptors.ContainsKey(operationName))
{
throw new ArgumentException("Operation is already registererd.");
}
if (TypeHelper.IsPrimitive(inputType) && string.IsNullOrEmpty(primitiveSpParameterName))
{
throw new ArgumentException("Input parameter of primitive type must provide name explicitly.");
}
if (string.IsNullOrEmpty(storedProcedureName))
{
storedProcedureName = "usp" + operationName;
}
var descriptor = new OperationRegisterDescriptor
{
OperationName = operationName,
SpName = storedProcedureName,
InputType = inputType,
ReturnDataType = returnDataType
};
this._descriptors.Add(descriptor.OperationName, descriptor);
return(this);
}
public override void IncludeDependencies(CatalogDeviceSession session, Catalog sourceCatalog, Catalog targetCatalog, EmitMode mode)
{
if ((SourceOperatorName != null) && (mode == EmitMode.ForRemote))
{
var sourceObjectName = MetaData.GetTag(MetaData, "DAE.SourceObjectName", SourceOperatorName);
sourceCatalog[sourceObjectName].IncludeDependencies(session, sourceCatalog, targetCatalog, mode);
}
else
{
if (!targetCatalog.Contains(this))
{
targetCatalog.Add(this);
base.IncludeDependencies(session, sourceCatalog, targetCatalog, mode);
foreach (Operand operand in Operands)
{
operand.DataType.IncludeDependencies(session, sourceCatalog, targetCatalog, mode);
}
if (ReturnDataType != null)
{
ReturnDataType.IncludeDependencies(session, sourceCatalog, targetCatalog, mode);
}
}
}
}
public object Run(string spName, IList parameters, ReturnDataType returnValue)
{
if (sqlConnection == null)
{
sqlConnection = new SqlConnection(StringCon);
}
if (sqlConnection.State != ConnectionState.Open)
{
sqlConnection.Open();
}
object valueReturn = null;
SqlParameter[] SQLparameters = new SqlParameter[parameters.Count];
int index = 0;
foreach (Parametro obj in parameters)
{
SQLparameters[index] = new SqlParameter(obj.Nombre, obj.Valor);
index++;
}
switch (returnValue)
{
case ReturnDataType.Nothing:
if (sqlTransaction == null)
{
SqlHelper.ExecuteNonQuery(sqlConnection, spName, SQLparameters);
sqlConnection.Close();
}
else
{
SqlHelper.ExecuteNonQuery(sqlTransaction, spName, SQLparameters);
}
valueReturn = null;
break;
case ReturnDataType.Scalar:
if (sqlTransaction == null)
{
valueReturn = SqlHelper.ExecuteScalar(sqlConnection, spName, SQLparameters);
sqlConnection.Close();
}
else
{
valueReturn = SqlHelper.ExecuteScalar(sqlTransaction, spName, SQLparameters);
}
break;
case ReturnDataType.Dataset:
if (sqlTransaction == null)
{
valueReturn = SqlHelper.ExecuteDataset(sqlConnection, spName, SQLparameters);
sqlConnection.Close();
}
else
{
valueReturn = SqlHelper.ExecuteDataset(sqlTransaction, spName, SQLparameters);
}
break;
default:
break;
}
return(valueReturn);
}
public AddRequestType() {
this.returnDataField = ReturnDataType.everything;
}
public override Statement EmitStatement(EmitMode mode)
{
if (mode == EmitMode.ForStorage)
{
SaveObjectID();
SaveLocator();
}
else
{
RemoveObjectID();
RemoveLocator();
}
try
{
IMetaData result;
if ((mode != EmitMode.ForRemote) && (DeclarationText != null))
{
SourceStatement statement = new SourceStatement();
statement.Source = DeclarationText + InitializationText + AggregationText + FinalizationText;
result = statement;
}
else
{
CreateAggregateOperatorStatement statement = new CreateAggregateOperatorStatement();
statement.OperatorName = Schema.Object.EnsureRooted(OperatorName);
foreach (Operand operand in Operands)
{
FormalParameter formalParameter = new FormalParameter();
formalParameter.Identifier = operand.Name;
formalParameter.TypeSpecifier = operand.DataType.EmitSpecifier(mode);
formalParameter.Modifier = operand.Modifier;
statement.FormalParameters.Add(formalParameter);
}
statement.ReturnType = ReturnDataType.EmitSpecifier(mode);
#if USEVIRTUAL
statement.IsVirtual = IsVirtual;
statement.IsAbstract = IsAbstract;
statement.IsOverride = IsOverride;
statement.IsReintroduced = IsReintroduced;
#endif
if ((mode == EmitMode.ForRemote) && !IsRemotable)
{
statement.Initialization.Block = new Block();
statement.Aggregation.Block = new Block();
statement.Finalization.Block = new Block();
}
else
{
Initialization.EmitStatement(mode, statement.Initialization);
Aggregation.EmitStatement(mode, statement.Aggregation);
Finalization.EmitStatement(mode, statement.Finalization);
}
result = statement;
}
result.MetaData = MetaData == null ? null : MetaData.Copy();
if (SessionObjectName != null)
{
if (result.MetaData == null)
{
result.MetaData = new MetaData();
}
result.MetaData.Tags.AddOrUpdate("DAE.GlobalObjectName", OperatorName, true);
}
return((Statement)result);
}
finally
{
if (mode == EmitMode.ForStorage)
{
RemoveObjectID();
RemoveLocator();
}
}
}
