internal override void SetIndex(string name, object value)
{
if (TrySet(TypedParameters, name, value, (v, t) => this[t.Item1] = value))
{
return;
}
var prop = InternalParameters.Where(p => HasName(p, name)).ToList();
if (prop.Count == 0 && IsLocked())
{
throw new InvalidOperationException($"Parameter with name '{name}' does not exist. To add new parameters object must first be unlocked.");
}
if (IsSensorTarget(value))
{
foreach (var obj in prop)
{
InternalParameters.Remove(obj);
}
Add(name, value);
}
else
{
SetOrAddCustom(prop, name, value);
}
}
int PrepareSimpleQuery(StringBuilder sb, string query, IList userParametersList, int userParametersListStart)
{
int queryCurrentPosition = 0;
int userParametersListPosition = userParametersListStart;
if (userParametersList.Count > 0) {
for (SimpleMatch m = ParameterRegExp.Match(query);
m.Success;m = m.NextMatch()) {
SimpleCapture parameterCapture = m;
sb.Append(query,queryCurrentPosition,parameterCapture.Index - queryCurrentPosition);
// advance in query
queryCurrentPosition = parameterCapture.Index + parameterCapture.Length;
AbstractDbParameter userParameter = GetUserParameter(parameterCapture.Value, userParametersList, userParametersListPosition);
if (userParameter != null) {
if (IsNullParameter(userParameter)) {
sb.Append("null");
NullParametersInPrepare = true;
}
else {
sb.Append('?');
InternalParameters.Add(userParameter);
}
// advance in user parameters
userParametersListPosition++;
}
else {
sb.Append(parameterCapture.Value);
}
}
}
sb.Append(query,queryCurrentPosition,query.Length - queryCurrentPosition);
int userParamsConsumed = userParametersListPosition - userParametersListStart;
if ((Behavior & CommandBehavior.KeyInfo) == 0)
return userParamsConsumed;
AbstractDBConnection connection = (AbstractDBConnection)Connection;
if (connection == null)
return userParamsConsumed;
string dbname = connection.JdbcConnection.getMetaData().getDatabaseProductName();
if (dbname == "Microsoft SQL Server") { //must add "FOR BROWSE" for selects
#if USE_DOTNET_REGEX
if (!SqlStatementsHelper.ForBrowseStatementReqExp.IsMatch(query))
sb.Append(" FOR BROWSE");
#else
if (!SqlStatementsHelper.ForBrowseStatementReqExp.matcher ((java.lang.CharSequence)(object)query).find ())
sb.Append (" FOR BROWSE");
#endif
}
return userParamsConsumed;
}
internal void Add(string name, object value)
{
var param = new CustomParameter(name, null, ParameterType.MultiParameter);
var parameterValue = container.CreateValue(name, value, trimName);
param.Value = parameterValue;
InternalParameters.Add(param);
container.Add(parameterValue);
}
/// <summary>
/// Removes a parameter from the underlying parameter set.
/// </summary>
/// <param name="name">The name of the parameter to remove.</param>
/// <returns>True if the specified parameter was found and removed. Otherwise, false.</returns>
protected bool RemoveCustomParameterInternal(string name)
{
var index = GetCustomParameterIndex(name);
if (index == -1)
{
return(false);
}
InternalParameters.RemoveAt(index);
return(true);
}
void ICustomParameterContainer.AddParameter(CustomParameter parameter)
{
var index = GetCustomParameterIndex(parameter.Name);
if (index == -1)
{
InternalParameters.Add(parameter);
}
else
{
InternalParameters[index] = parameter;
}
}
internal virtual void SetIndex(string name, object value)
{
if (TrySet(TypedParameters, name, value, (v, t) => this[t.Item1] = value))
{
return;
}
if (TrySet(TypedProperties, name, value, (v, t) => t.Item2.SetValue(this, v)))
{
return;
}
var props = InternalParameters.Where(p => HasName(p, name, trimName)).ToList();
SetOrAddCustom(props, name, value);
}
internal bool RemoveInternal(string name, bool ignoreUnderscore)
{
var toRemove = InternalParameters.Where(p => HasName(p, name, ignoreUnderscore)).ToList();
if (toRemove.Count == 0)
{
return(false);
}
foreach (var obj in toRemove)
{
InternalParameters.Remove(obj);
}
return(true);
}
/// <summary>
/// Store the value of a property in the underlying set, using its raw serialized name.
/// </summary>
/// <param name="name">The raw name of the parameter.</param>
/// <param name="value">The value to store.</param>
protected void SetCustomParameterInternal(string name, object value)
{
value = PSObjectHelpers.CleanPSObject(value);
var parameter = new CustomParameter(name, value);
var index = GetCustomParameterIndex(name);
if (index == -1)
{
InternalParameters.Add(parameter);
}
else
{
InternalParameters[index] = parameter;
}
}
internal void Add(string name, object value)
{
var param = new CustomParameter(name, null, ParameterType.MultiParameter);
var var = new PSVariableEx(
name,
value,
v => this[name] = v,
trimName
);
param.Value = var;
InternalParameters.Add(param);
//Add will replace the existing property value if a member with the same name already exists
psObject.Properties.Add(new PSVariableProperty(var));
}
private object GetIndex(string name)
{
Tuple <Parameter, PropertyInfo> param;
Tuple <ObjectProperty, PropertyInfo> prop;
if (TypedParameters.TryGetValue(name, out param, true))
{
return(this[param.Item1]);
}
if (TypedProperties.TryGetValue(name, out prop, true, trimName))
{
return(prop.Item2.GetValue(this));
}
var matches = InternalParameters
.Where(p => HasName(p, name, trimName))
.Select(p =>
{
if (p.Value is IParameterContainerValue)
{
return(((IParameterContainerValue)p.Value).Value);
}
return(p.Value);
})
.ToList();
if (matches.Count == 1)
{
return(matches.First());
}
if (matches.Count > 0)
{
if (matches.All(o => o is GenericSensorTarget))
{
return(matches.Cast <GenericSensorTarget>().ToArray());
}
throw new NotSupportedException($"Property '{name}' contains an invalid collection of elements");
}
throw new InvalidOperationException($"Parameter with name '{name}' does not exist.");
}
protected MultivariateDistributionSettings(InternalParameters parameters)
{
if (parameters.CovarianceMatrix == null)
{
throw new ArgumentNullException(nameof(parameters.CovarianceMatrix));
}
if (parameters.Means == null)
{
throw new ArgumentNullException(nameof(parameters.Means));
}
if (!parameters.CovarianceMatrix.IsSquare())
{
throw new DistributionsArgumentException(DistributionsArgumentExceptionType.CovarianceMatrixMustBeSquare);
}
if (!parameters.CovarianceMatrix.IsSymmetric())
{
throw new DistributionsArgumentException(DistributionsArgumentExceptionType.CovarianceMatrixMustBeSymmetric);
}
if (parameters.Means.Length != parameters.CovarianceMatrix.GetLength(0))
{
throw new DistributionsArgumentException(DistributionsArgumentExceptionType.VectorOfMeansMustBeEqualToDimension);
}
Dimension = parameters.Means.Length;
CovarianceMatrix = parameters.CovarianceMatrix;
Means = parameters.Means;
Chol = new CholeskyDecomposition(CovarianceMatrix);
if (!Chol.IsPositiveDefinite)
{
throw new DistributionsArgumentException(DistributionsArgumentExceptionType.CovarianceMatrixMustBePositiveDefined);
}
}
private int GetCustomParameterIndex(string name)
{
var index = InternalParameters.FindIndex(a => a.Name == name);
return(index);
}
protected virtual void PrepareInternalParameters()
{
InternalParameters.Clear();
}
public override bool Define (TypeContainer parent)
{
PropertyAttributes prop_attr =
PropertyAttributes.RTSpecialName |
PropertyAttributes.SpecialName;
if (!DoDefine (parent))
return false;
IndexerName = Attribute.ScanForIndexerName (ec, OptAttributes);
if (IndexerName == null)
IndexerName = "Item";
else if (IsExplicitImpl)
Report.Error (592, Location,
"Attribute 'IndexerName' is not valid on this declaration " +
"type. It is valid on `property' declarations only.");
ShortName = IndexerName;
if (IsExplicitImpl) {
InterfaceIndexerName = TypeManager.IndexerPropertyName (InterfaceType);
Name = InterfaceType.FullName + "." + IndexerName;
} else {
InterfaceIndexerName = IndexerName;
Name = ShortName;
}
if (!CheckBase (parent))
return false;
flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName;
if (Get != null){
InternalParameters ip = new InternalParameters (parent, Parameters);
GetData = new MethodData (this, "get", MemberType,
ParameterTypes, ip, CallingConventions.Standard,
Get.OptAttributes, ModFlags, flags, false);
if (!GetData.Define (parent))
return false;
GetBuilder = GetData.MethodBuilder;
}
if (Set != null){
int top = ParameterTypes.Length;
Type [] set_pars = new Type [top + 1];
ParameterTypes.CopyTo (set_pars, 0);
set_pars [top] = MemberType;
Parameter [] fixed_parms = Parameters.FixedParameters;
if (fixed_parms == null){
throw new Exception ("We currently do not support only array arguments in an indexer");
// BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
// BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
//
// Here is the problem: the `value' parameter has
// to come *after* the array parameter in the declaration
// like this:
// X (object [] x, Type value)
// .param [0]
//
// BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
// BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
}
Parameter [] tmp = new Parameter [fixed_parms.Length + 1];
fixed_parms.CopyTo (tmp, 0);
tmp [fixed_parms.Length] = new Parameter (
Type, "value", Parameter.Modifier.NONE, null);
Parameters set_formal_params = new Parameters (tmp, null, Location);
InternalParameters ip = new InternalParameters (parent, set_formal_params);
SetData = new MethodData (this, "set", TypeManager.void_type,
set_pars, ip, CallingConventions.Standard,
Set.OptAttributes, ModFlags, flags, false);
if (!SetData.Define (parent))
return false;
SetBuilder = SetData.MethodBuilder;
}
//
// Now name the parameters
//
Parameter [] p = Parameters.FixedParameters;
if (p != null) {
int i;
for (i = 0; i < p.Length; ++i) {
if (Get != null)
GetBuilder.DefineParameter (
i + 1, p [i].Attributes, p [i].Name);
if (Set != null)
SetBuilder.DefineParameter (
i + 1, p [i].Attributes, p [i].Name);
}
if (Set != null)
SetBuilder.DefineParameter (
i + 1, ParameterAttributes.None, "value");
if (i != ParameterTypes.Length) {
Parameter array_param = Parameters.ArrayParameter;
SetBuilder.DefineParameter (
i + 1, array_param.Attributes, array_param.Name);
}
}
if (GetData != null)
IsImplementing = GetData.IsImplementing;
else if (SetData != null)
IsImplementing = SetData.IsImplementing;
//
// Define the PropertyBuilder if one of the following conditions are met:
// a) we're not implementing an interface indexer.
// b) the indexer has a different IndexerName and this is no
// explicit interface implementation.
//
if (!IsExplicitImpl) {
PropertyBuilder = parent.TypeBuilder.DefineProperty (
IndexerName, prop_attr, MemberType, ParameterTypes);
if (GetData != null)
PropertyBuilder.SetGetMethod (GetBuilder);
if (SetData != null)
PropertyBuilder.SetSetMethod (SetBuilder);
TypeManager.RegisterIndexer (PropertyBuilder, GetBuilder, SetBuilder,
ParameterTypes);
}
return true;
}
protected override void PrepareInternalParameters() {
InternalParameters.Clear();
_currentParameterIndex = -1;
}
public override bool Define (TypeContainer parent)
{
if (!DoDefine (parent))
return false;
if (!CheckBase (parent))
return false;
flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName;
if (Get != null) {
Type [] parameters = TypeManager.NoTypes;
InternalParameters ip = new InternalParameters (
parent, Parameters.EmptyReadOnlyParameters);
GetData = new MethodData (this, "get", MemberType,
parameters, ip, CallingConventions.Standard,
Get.OptAttributes, ModFlags, flags, false);
if (!GetData.Define (parent))
return false;
GetBuilder = GetData.MethodBuilder;
}
if (Set != null) {
Type [] parameters = new Type [1];
parameters [0] = MemberType;
Parameter [] parms = new Parameter [1];
parms [0] = new Parameter (Type, "value", Parameter.Modifier.NONE, null);
InternalParameters ip = new InternalParameters (
parent, new Parameters (parms, null, Location));
SetData = new MethodData (this, "set", TypeManager.void_type,
parameters, ip, CallingConventions.Standard,
Set.OptAttributes, ModFlags, flags, false);
if (!SetData.Define (parent))
return false;
SetBuilder = SetData.MethodBuilder;
SetBuilder.DefineParameter (1, ParameterAttributes.None, "value");
}
// FIXME - PropertyAttributes.HasDefault ?
PropertyAttributes prop_attr =
PropertyAttributes.RTSpecialName |
PropertyAttributes.SpecialName;
if (!IsExplicitImpl){
PropertyBuilder = parent.TypeBuilder.DefineProperty (
Name, prop_attr, MemberType, null);
if (Get != null)
PropertyBuilder.SetGetMethod (GetBuilder);
if (Set != null)
PropertyBuilder.SetSetMethod (SetBuilder);
//
// HACK for the reasons exposed above
//
if (!TypeManager.RegisterProperty (PropertyBuilder, GetBuilder, SetBuilder)) {
Report.Error (
111, Location,
"Class `" + parent.Name +
"' already contains a definition for the property `" +
Name + "'");
return false;
}
}
return true;
}
public override bool Define (TypeContainer parent)
{
EventAttributes e_attr = EventAttributes.RTSpecialName | EventAttributes.SpecialName;
if (!DoDefine (parent))
return false;
if (init != null && ((ModFlags & Modifiers.ABSTRACT) != 0)){
Report.Error (74, Location, "'" + parent.Name + "." + Name +
"': abstract event can not have an initializer");
return false;
}
if (!MemberType.IsSubclassOf (TypeManager.delegate_type)) {
Report.Error (66, Location, "'" + parent.Name + "." + Name +
"' : event must be of a delegate type");
return false;
}
Type [] parameter_types = new Type [1];
parameter_types [0] = MemberType;
Parameter [] parms = new Parameter [1];
parms [0] = new Parameter (Type, "value", Parameter.Modifier.NONE, null);
InternalParameters ip = new InternalParameters (
parent, new Parameters (parms, null, Location));
if (!CheckBase (parent))
return false;
//
// Now define the accessors
//
AddData = new MethodData (this, "add", TypeManager.void_type,
parameter_types, ip, CallingConventions.Standard,
(Add != null) ? Add.OptAttributes : null,
ModFlags, flags, false);
if (!AddData.Define (parent))
return false;
AddBuilder = AddData.MethodBuilder;
AddBuilder.DefineParameter (1, ParameterAttributes.None, "value");
RemoveData = new MethodData (this, "remove", TypeManager.void_type,
parameter_types, ip, CallingConventions.Standard,
(Remove != null) ? Remove.OptAttributes : null,
ModFlags, flags, false);
if (!RemoveData.Define (parent))
return false;
RemoveBuilder = RemoveData.MethodBuilder;
RemoveBuilder.DefineParameter (1, ParameterAttributes.None, "value");
if (!IsExplicitImpl){
EventBuilder = new MyEventBuilder (this,
parent.TypeBuilder, Name, e_attr, MemberType);
if (Add == null && Remove == null) {
FieldBuilder = parent.TypeBuilder.DefineField (
Name, MemberType,
FieldAttributes.Private | ((ModFlags & Modifiers.STATIC) != 0 ? FieldAttributes.Static : 0));
TypeManager.RegisterPrivateFieldOfEvent (
(EventInfo) EventBuilder, FieldBuilder);
TypeManager.RegisterFieldBase (FieldBuilder, this);
}
EventBuilder.SetAddOnMethod (AddBuilder);
EventBuilder.SetRemoveOnMethod (RemoveBuilder);
if (!TypeManager.RegisterEvent (EventBuilder, AddBuilder, RemoveBuilder)) {
Report.Error (111, Location,
"Class `" + parent.Name +
"' already contains a definition for the event `" +
Name + "'");
return false;
}
}
return true;
}
public MethodData (MemberBase member, string name, Type return_type,
Type [] parameter_types, InternalParameters parameters,
CallingConventions cc, Attributes opt_attrs,
int modifiers, MethodAttributes flags, bool is_method)
{
this.member = member;
this.accessor_name = name;
this.ReturnType = return_type;
this.ParameterTypes = parameter_types;
this.ParameterInfo = parameters;
this.CallingConventions = cc;
this.OptAttributes = opt_attrs;
this.modifiers = modifiers;
this.flags = flags;
this.is_method = is_method;
this.Location = member.Location;
this.conditionals = new ArrayList ();
}
public bool IsEntryPoint (MethodBuilder b, InternalParameters pinfo)
{
if (b.ReturnType != TypeManager.void_type &&
b.ReturnType != TypeManager.int32_type)
return false;
if (pinfo.Count == 0)
return true;
if (pinfo.Count > 1)
return false;
Type t = pinfo.ParameterType(0);
if (t.IsArray &&
(t.GetArrayRank() == 1) &&
(t.GetElementType() == TypeManager.string_type) &&
(pinfo.ParameterModifier(0) == Parameter.Modifier.NONE))
return true;
else
return false;
}
/// <summary>
/// contructor
/// </summary>
/// <param name="ACriteriaData"></param>
public TPartnerLocationFindUIConnector(DataTable ACriteriaData) : base()
{
Hashtable ColumnNameMapping;
String CustomWhereCriteria;
ArrayList InternalParameters;
OdbcParameter miParam;
DataRow CriteriaRow;
FPagedDataSetObject = new TPagedDataSet(new PartnerFindTDSSearchResultTable());
ColumnNameMapping = null;
// get the first and only row
CriteriaRow = ACriteriaData.Rows[0];
// used to help with strong typing of columns
InternalParameters = new ArrayList();
CustomWhereCriteria = "";
if (CriteriaRow["Addr1"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnLocalityId, CriteriaRow, "Addr1", "Addr1Match", ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["Street2"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnStreetNameId, CriteriaRow, "Street2", "Street2Match",
ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["Addr3"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnAddress3Id, CriteriaRow, "Addr3", "Addr3Match", ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["City"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnCityId, CriteriaRow, "City", "CityMatch", ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["PostCode"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnPostalCodeId, CriteriaRow, "PostCode", "PostCodeMatch",
ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["County"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnCountyId, CriteriaRow, "County", "CountyMatch", ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["Country"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnCountryCodeId, CriteriaRow, "Country", "CountryMatch",
ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["LocationKey"].ToString().Length > 0)
{
// DISREGARD ALL OTHER SEARCH CRITERIA!!!
CustomWhereCriteria = "";
InternalParameters = new ArrayList();
CustomWhereCriteria = String.Format("{0} AND PUB.{1}.{2} = ?", CustomWhereCriteria,
PLocationTable.GetTableDBName(), PLocationTable.GetLocationKeyDBName());
miParam = new OdbcParameter("", OdbcType.Decimal, 10);
miParam.Value = (object)CriteriaRow["LocationKey"];
InternalParameters = new ArrayList();
InternalParameters.Add(miParam);
}
Console.WriteLine("WHERE CLAUSE: " + CustomWhereCriteria);
FPagedDataSetObject.FindParameters = new TPagedDataSet.TAsyncFindParameters(
" p_city_c, p_postal_code_c, p_locality_c, p_street_name_c, p_address_3_c, p_county_c, p_country_code_c, p_location_key_i, p_site_key_n ",
"PUB_p_location ",
" p_location_key_i<>-1 " + CustomWhereCriteria + ' ',
"p_city_c ",
ColumnNameMapping,
((OdbcParameter[])(InternalParameters.ToArray(typeof(OdbcParameter)))));
// fields
// table
// where
// order by
// both empty for now
string session = TSession.GetSessionID();
//
// Start the Find Thread
//
try
{
ThreadStart myThreadStart = delegate {
FPagedDataSetObject.ExecuteQuery(session);
};
FFindThread = new Thread(myThreadStart);
FFindThread.Name = "PartnerLocationFind" + Guid.NewGuid().ToString();
FFindThread.Start();
}
catch (Exception)
{
throw;
}
}
string CreateStoredProcedureCommandTextSimple(string procedureName, IDataParameterCollection userParams, IList derivedParams) {
StringBuilder sb = new StringBuilder();
int curUserPos = 0;
int curDerivedPos = 0;
bool addParas = true;
string trimedProcedureName = (procedureName != null) ? procedureName.TrimEnd() : String.Empty;
if (trimedProcedureName.Length > 0 && trimedProcedureName[trimedProcedureName.Length-1] == ')')
addParas = false;
AbstractDbParameter derivedParam = (derivedParams.Count > 0) ? (AbstractDbParameter)derivedParams[curDerivedPos] : null;
if (derivedParam != null) {
if (derivedParam.Direction == ParameterDirection.ReturnValue)
curDerivedPos++;
else
derivedParam = null; //play as if there is no retval parameter
}
AbstractDbParameter returnValueParameter = GetReturnParameter (userParams);
if (returnValueParameter != null) {
curUserPos++;
InternalParameters.Add(returnValueParameter);
sb.Append("{? = call ");
if (derivedParam != null && !returnValueParameter.IsDbTypeSet) {
returnValueParameter.JdbcType = derivedParam.JdbcType;
}
}
else {
sb.Append("{call ");
}
sb.Append(procedureName);
if (addParas)
sb.Append('(');
bool needComma = false;
for (int i = curDerivedPos; i < derivedParams.Count; i++) {
AbstractDbParameter derivedParameter = (AbstractDbParameter)derivedParams[curDerivedPos++];
bool addParam = false;
if (derivedParameter.IsSpecial) {
// derived parameter is special - never appears in user parameters or user values
InternalParameters.Add((AbstractDbParameter)derivedParameter.Clone());
addParam = true;
}
else {
AbstractDbParameter userParameter = GetUserParameter(derivedParameter.Placeholder, userParams, curUserPos);
if (userParameter != null) {
curUserPos++;
InternalParameters.Add(userParameter);
addParam = true;
if (derivedParameter != null && !userParameter.IsDbTypeSet) {
userParameter.JdbcType = derivedParameter.JdbcType;
}
}
}
if (addParam) {
if (needComma)
sb.Append(',');
else
needComma = true;
sb.Append('?');
}
}
for (int i = curUserPos; i < userParams.Count; i++) {
if (needComma)
sb.Append(',');
else
needComma = true;
AbstractDbParameter userParameter = (AbstractDbParameter)userParams[curUserPos++];
InternalParameters.Add(userParameter);
sb.Append('?');
}
if (addParas)
sb.Append(')');
sb.Append('}');
return sb.ToString();
}
int CreateStoredProcedureCommandText(StringBuilder sb, string sql, Matcher match, IDataParameterCollection userParams, int userParamsStartPosition)
#endif
{
int curUserPos = userParamsStartPosition;
#if USE_DOTNET_REGEX
Group procNameGroup = null;
for (Match procNameMatch = match; procNameMatch.Success; procNameMatch = procNameMatch.NextMatch()){
procNameGroup = match.Groups["PROCNAME"];
if (!procNameGroup.Success) {
continue;
}
}
if (procNameGroup == null || !procNameGroup.Success)
throw new ArgumentException("Not a stored procedure call: '{0}'", sql);
ArrayList derivedParameters = DeriveParameters(procNameGroup.Value, false);
#else
ArrayList derivedParameters = DeriveParameters(match.group(2).Trim(), false);
#endif
int curDerivedPos = 0;
AbstractDbParameter retValderivedParameter = curDerivedPos < derivedParameters.Count ?
(AbstractDbParameter)derivedParameters[curDerivedPos] : null;
if (retValderivedParameter != null && retValderivedParameter.Direction == ParameterDirection.ReturnValue)
curDerivedPos++;
int queryCurrentPosition = 0;
#if USE_DOTNET_REGEX
for (Match retValMatch = match; retValMatch.Success; retValMatch = retValMatch.NextMatch()){
Group retval = retValMatch.Groups["RETVAL"];
if (!retval.Success) {
continue;
}
int retvalIndex = retval.Index;
string retvalValue = retval.Value;
int retvalLength = retval.Length;
#else
int retvalIndex = match.start(1);
for (;retvalIndex >= 0;) {
string retvalValue = match.group(1);
int retvalLength = retvalValue.Length;
#endif
sb.Append(sql, queryCurrentPosition, retvalIndex);
AbstractDbParameter userParameter = GetUserParameter(retvalValue, userParams, curUserPos);
if (userParameter != null) {
sb.Append('?');
InternalParameters.Add(userParameter);
if (retValderivedParameter != null && !userParameter.IsDbTypeSet) {
userParameter.JdbcType = retValderivedParameter.JdbcType;
}
curUserPos++;
}
else {
sb.Append(retvalValue);
}
queryCurrentPosition = (retvalIndex + retvalLength);
break;
}
#if USE_DOTNET_REGEX
sb.Append(sql, queryCurrentPosition, procNameGroup.Index + procNameGroup.Length - queryCurrentPosition);
queryCurrentPosition = procNameGroup.Index + procNameGroup.Length;
#else
sb.Append(sql, queryCurrentPosition, match.end(2) - queryCurrentPosition);
queryCurrentPosition = match.end(2);
#endif
bool hasUserParams = false;
#if USE_DOTNET_REGEX
must rewrite the regex to not parse params to have single code with java regex
#else
int paramsStart = match.start(3);
if (paramsStart >= 0) {
#endif
hasUserParams = true;
sb.Append(sql,queryCurrentPosition,paramsStart - queryCurrentPosition);
queryCurrentPosition = paramsStart;
for (SimpleMatch m = SqlStatementsHelper.ProcedureParameterSplitterReqExp.Match(match.group(3));
m.Success;m = m.NextMatch()) {
SimpleCapture parameterCapture = m;
sb.Append(sql,queryCurrentPosition,paramsStart + parameterCapture.Index - queryCurrentPosition);
// advance in query
queryCurrentPosition = paramsStart + parameterCapture.Index + parameterCapture.Length;
AbstractDbParameter derivedParameter = curDerivedPos < derivedParameters.Count ?
(AbstractDbParameter)derivedParameters[curDerivedPos++] : null;
//check for special params
while (derivedParameter != null && derivedParameter.IsSpecial) {
// derived parameter is special - never appears in user parameters or user values
InternalParameters.Add((AbstractDbParameter)derivedParameter.Clone());
sb.Append('?');
sb.Append(',');
derivedParameter = curDerivedPos < derivedParameters.Count ?
(AbstractDbParameter)derivedParameters[curDerivedPos++] : null;
}
AbstractDbParameter userParameter = GetUserParameter(parameterCapture.Value.Trim(), userParams, curUserPos);
if (userParameter != null) {
sb.Append('?');
InternalParameters.Add(userParameter);
if (derivedParameter != null && !userParameter.IsDbTypeSet) {
userParameter.JdbcType = derivedParameter.JdbcType;
}
// advance in user parameters
curUserPos++;
}
else {
sb.Append(parameterCapture.Value);
}
}
}
bool addedSpecialParams = false;
for (int i = curDerivedPos; i < derivedParameters.Count;) {
AbstractDbParameter derivedParameter = (AbstractDbParameter)derivedParameters[i++];
if (derivedParameter.IsSpecial) {
// derived parameter is special - never appears in user parameters or user values
if (!hasUserParams && !addedSpecialParams) {
addedSpecialParams = true;
curDerivedPos++;
sb.Append('(');
}
for (;curDerivedPos < i;curDerivedPos++)
sb.Append(',');
InternalParameters.Add((AbstractDbParameter)derivedParameter.Clone());
sb.Append('?');
}
}
if (!hasUserParams && addedSpecialParams)
sb.Append(')');
sb.Append(sql,queryCurrentPosition,sql.Length - queryCurrentPosition);
return curUserPos - userParamsStartPosition;
}
internal bool ContainsInternal(string name, bool ignoreUnderscore) => InternalParameters.Any(p => HasName(p, name, ignoreUnderscore));
public bool RegisterMethod (MethodBuilder mb, InternalParameters ip, Type [] args)
{
if (builder_and_args == null)
builder_and_args = new Hashtable ();
return true;
}
/// <summary>
/// Used internally to build a SQL WHERE criteria from the AFindCriteria HashTable.
///
/// </summary>
/// <param name="ACriteriaData">HashTable containing non-empty Partner Find parameters</param>
/// <param name="AParametersArray">An array holding 1..n instantiated OdbcParameters
/// (including parameter Value)</param>
/// <returns>SQL WHERE criteria
/// </returns>
private String BuildCustomWhereCriteria(DataTable ACriteriaData, out OdbcParameter[] AParametersArray)
{
String CustomWhereCriteria = "";
DataTable CriteriaDataTable;
DataRow CriteriaRow;
ArrayList InternalParameters;
OdbcParameter miParam;
CriteriaDataTable = ACriteriaData;
CriteriaRow = CriteriaDataTable.Rows[0];
InternalParameters = new ArrayList();
if (CriteriaRow["Addr1"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnLocalityId, CriteriaRow, "Addr1", "Addr1Match", ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["Street2"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnStreetNameId, CriteriaRow, "Street2", "Street2Match",
ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["Addr3"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnAddress3Id, CriteriaRow, "Addr3", "Addr3Match", ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["City"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnCityId, CriteriaRow, "City", "CityMatch", ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["PostCode"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnPostalCodeId, CriteriaRow, "PostCode", "PostCodeMatch",
ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["County"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnCountyId, CriteriaRow, "County", "CountyMatch", ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["Country"].ToString().Length > 0)
{
new TDynamicSearchHelper(PLocationTable.TableId,
PLocationTable.ColumnCountryCodeId, CriteriaRow, "Country", "CountryMatch",
ref CustomWhereCriteria,
ref InternalParameters);
}
if (CriteriaRow["LocationKey"].ToString().Length > 0)
{
// DISREGARD ALL OTHER SEARCH CRITERIA!!!
CustomWhereCriteria = "";
InternalParameters = new ArrayList();
CustomWhereCriteria = String.Format("{0} AND PUB.{1}.{2} = ?", CustomWhereCriteria,
PLocationTable.GetTableDBName(), PLocationTable.GetLocationKeyDBName());
miParam = new OdbcParameter("", OdbcType.Decimal, 10);
miParam.Value = (object)CriteriaRow["LocationKey"];
InternalParameters = new ArrayList();
InternalParameters.Add(miParam);
}
// TLogging.LogAtLevel(7, "CustomWhereCriteria: " + CustomWhereCriteria);
/* Convert ArrayList to a array of ODBCParameters
* seem to need to declare a type first
*/
AParametersArray = ((OdbcParameter[])(InternalParameters.ToArray(typeof(OdbcParameter))));
InternalParameters = null; // ensure this is GC'd
return(CustomWhereCriteria);
}
protected virtual bool DoDefineParameters (TypeContainer parent)
{
// Check if arguments were correct
parameter_types = Parameters.GetParameterInfo (parent);
if ((parameter_types == null) || !CheckParameters (parent, parameter_types))
return false;
parameter_info = new InternalParameters (parent, Parameters);
return true;
}
