internal QueryInstancesJob(CimJobContext jobContext, CimQuery cimQuery, string wqlCondition)
: base(jobContext, cimQuery)
{
Dbg.Assert(wqlCondition != null, "Caller should verify that wqlCondition is not null");
var wqlQueryBuilder = new StringBuilder();
wqlQueryBuilder.Append("SELECT * FROM ");
wqlQueryBuilder.Append(this.JobContext.ClassName);
wqlQueryBuilder.Append(" ");
wqlQueryBuilder.Append(wqlCondition);
_wqlQuery = wqlQueryBuilder.ToString();
if (string.IsNullOrWhiteSpace(wqlCondition))
{
_useEnumerateInstances = true;
}
else
{
if (jobContext.CmdletInvocationContext.CmdletDefinitionContext.UseEnumerateInstancesInsteadOfWql)
{
_useEnumerateInstances = true;
}
}
}
internal override StartableJob CreateQueryJob(CimSession session, QueryBuilder baseQuery)
{
CimQuery cimQuery = baseQuery as CimQuery;
if (cimQuery != null)
{
TerminatingErrorTracker tracker = TerminatingErrorTracker.GetTracker(this.CmdletInvocationInfo, false);
if (!tracker.IsSessionTerminated(session))
{
if (this.IsSupportedSession(session, tracker))
{
CimJobContext cimJobContext = this.CreateJobContext(session, null);
StartableJob queryJob = cimQuery.GetQueryJob(cimJobContext);
return(queryJob);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
else
{
throw new ArgumentNullException("baseQuery");
}
}
/// <summary>
/// Creates a <see cref="System.Management.Automation.Job"/> object that performs a query against the wrapped object model.
/// </summary>
/// <param name="session">Remote session to query</param>
/// <param name="baseQuery">Query parameters</param>
/// <returns><see cref="System.Management.Automation.Job"/> object that performs a query against the wrapped object model</returns>
internal override StartableJob CreateQueryJob(CimSession session, QueryBuilder baseQuery)
{
CimQuery query = baseQuery as CimQuery;
if (query == null)
{
throw new ArgumentNullException("baseQuery");
}
TerminatingErrorTracker tracker = TerminatingErrorTracker.GetTracker(this.CmdletInvocationInfo, isStaticCmdlet: false);
if (tracker.IsSessionTerminated(session))
{
return(null);
}
if (!IsSupportedSession(session, tracker))
{
return(null);
}
CimJobContext jobContext = this.CreateJobContext(session, targetObject: null);
StartableJob queryJob = query.GetQueryJob(jobContext);
return(queryJob);
}
internal EnumerateAssociatedInstancesJob(CimJobContext jobContext, CimQuery cimQuery, CimInstance associatedObject, string associationName, string resultRole, string sourceRole) : base(jobContext, cimQuery)
{
this.associatedObject = associatedObject;
this.associationName = associationName;
this.resultRole = resultRole;
this.sourceRole = sourceRole;
}
private static string GetMatchConditionForEqualityOperator(string propertyName, object propertyValue)
{
string str;
if (propertyValue is char)
{
string wqlLiteral = CimQuery.ObjectToWqlLiteral(propertyValue);
if (!string.IsNullOrWhiteSpace(wqlLiteral))
{
object[] objArray = new object[2];
objArray[0] = propertyName;
objArray[1] = wqlLiteral;
str = string.Format(CultureInfo.InvariantCulture, "({0} = {1})", objArray);
return(str);
}
else
{
return(null);
}
}
else
{
char chr = (char)propertyValue;
char lowerInvariant = char.ToLowerInvariant(chr);
char upperInvariant = char.ToUpperInvariant(chr);
string wqlLiteral1 = CimQuery.ObjectToWqlLiteral(lowerInvariant);
string str1 = CimQuery.ObjectToWqlLiteral(upperInvariant);
object[] objArray1 = new object[3];
objArray1[0] = propertyName;
objArray1[1] = wqlLiteral1;
objArray1[2] = str1;
str = string.Format(CultureInfo.InvariantCulture, "(({0} = {1}) OR ({0} = {2}))", objArray1);
return(str);
}
}
private static string GetMatchCondition(string propertyName, IEnumerable propertyValues, bool wildcardsEnabled)
{
IEnumerable <string> strs = propertyValues.Cast <object>().Select <object, string>((object propertyValue) => {
if (wildcardsEnabled)
{
return(CimQuery.GetMatchConditionForLikeOperator(propertyName, propertyValue));
}
else
{
return(CimQuery.GetMatchConditionForEqualityOperator(propertyName, propertyValue));
}
}
);
List <string> list = strs.Where <string>((string individualCondition) => !string.IsNullOrWhiteSpace(individualCondition)).ToList <string>();
if (list.Count != 0)
{
string str = string.Join(" OR ", list);
return(str);
}
else
{
return(null);
}
}
public override void FilterByProperty(string propertyName, IEnumerable allowedPropertyValues, bool wildcardsEnabled, BehaviorOnNoMatch behaviorOnNoMatch)
{
this.ClientSideQuery.FilterByProperty(propertyName, allowedPropertyValues, wildcardsEnabled, behaviorOnNoMatch);
string matchCondition = CimQuery.GetMatchCondition(propertyName, allowedPropertyValues, wildcardsEnabled);
if (!string.IsNullOrWhiteSpace(matchCondition))
{
this.AddWqlCondition(matchCondition);
}
}
public override void ExcludeByProperty(string propertyName, IEnumerable excludedPropertyValues, bool wildcardsEnabled, BehaviorOnNoMatch behaviorOnNoMatch)
{
this.ClientSideQuery.ExcludeByProperty(propertyName, excludedPropertyValues, wildcardsEnabled, behaviorOnNoMatch);
string matchCondition = CimQuery.GetMatchCondition(propertyName, excludedPropertyValues, wildcardsEnabled);
if (!string.IsNullOrWhiteSpace(matchCondition))
{
object[] objArray = new object[1];
objArray[0] = matchCondition;
string str = string.Format(CultureInfo.InvariantCulture, "NOT ({0})", objArray);
this.AddWqlCondition(str);
}
}
private static string GetMatchConditionForLikeOperator(string propertyName, object propertyValue)
{
bool flag = false;
string str = (string)LanguagePrimitives.ConvertTo(propertyValue, typeof(string), CultureInfo.InvariantCulture);
WildcardPattern wildcardPattern = new WildcardPattern(str, WildcardOptions.IgnoreCase);
string wqlLikeOperand = CimQuery.WildcardToWqlLikeOperand(wildcardPattern, out flag);
object[] objArray = new object[2];
objArray[0] = propertyName;
objArray[1] = wqlLikeOperand;
string str1 = string.Format(CultureInfo.InvariantCulture, "({0} LIKE {1})", objArray);
return(str1);
}
public override void FilterByMinPropertyValue(string propertyName, object minPropertyValue, BehaviorOnNoMatch behaviorOnNoMatch)
{
this.ClientSideQuery.FilterByMinPropertyValue(propertyName, minPropertyValue, behaviorOnNoMatch);
string wqlLiteral = CimQuery.ObjectToWqlLiteral(minPropertyValue);
if (!string.IsNullOrWhiteSpace(wqlLiteral))
{
object[] objArray = new object[2];
objArray[0] = propertyName;
objArray[1] = wqlLiteral;
string str = string.Format(CultureInfo.InvariantCulture, "{0} >= {1}", objArray);
this.AddWqlCondition(str);
}
}
/// <summary>
/// Modifies the query, so that it does not return objects with a given property value
/// </summary>
/// <param name="propertyName">Property name to query on</param>
/// <param name="excludedPropertyValues">Property values to reject in the query</param>
/// <param name="wildcardsEnabled">
/// <c>true</c> if <paramref name="excludedPropertyValues"/> should be treated as a <see cref="System.String"/> containing a wildcard pattern;
/// <c>false otherwise</c>
/// </param>
/// <param name="behaviorOnNoMatch">
/// Describes how to handle filters that didn't match any objects
/// </param>
public override void ExcludeByProperty(string propertyName, IEnumerable excludedPropertyValues, bool wildcardsEnabled, BehaviorOnNoMatch behaviorOnNoMatch)
{
this.ClientSideQuery.ExcludeByProperty(propertyName, excludedPropertyValues, wildcardsEnabled, behaviorOnNoMatch);
string positiveWqlCondition = CimQuery.GetMatchCondition(propertyName, excludedPropertyValues, wildcardsEnabled);
if (!string.IsNullOrWhiteSpace(positiveWqlCondition))
{
string condition = string.Format(
CultureInfo.InvariantCulture,
"NOT ({0})",
positiveWqlCondition);
this.AddWqlCondition(condition);
}
}
internal EnumerateAssociatedInstancesJob(CimJobContext jobContext, CimQuery cimQuery, CimInstance associatedObject, string associationName, string resultRole, string sourceRole)
: base(jobContext, cimQuery)
{
_associatedObject = associatedObject;
Dbg.Assert(_associatedObject != null, "Caller should verify that associatedObject is not null");
_associationName = associationName;
Dbg.Assert(_associationName != null, "Caller should verify that associationName is not null");
_resultRole = resultRole;
Dbg.Assert(_resultRole != null, "Caller should verify that resultRole is not null");
_sourceRole = sourceRole;
Dbg.Assert(_sourceRole != null, "Caller should verify that sourceRole is not null");
}
private static string GetMatchConditionForLikeOperator(string propertyName, object propertyValue)
{
var expectedPropertyValueAsString = (string)LanguagePrimitives.ConvertTo(propertyValue, typeof(string), CultureInfo.InvariantCulture);
var expectedPropertyValueAsPowerShellWildcard = WildcardPattern.Get(expectedPropertyValueAsString, WildcardOptions.IgnoreCase);
bool needsClientSideFiltering; // not used because for simplicity all results go through post-filtering
var expectedPropertyValueAsWqlWildcard = CimQuery.WildcardToWqlLikeOperand(expectedPropertyValueAsPowerShellWildcard, out needsClientSideFiltering);
string condition = string.Format(
CultureInfo.InvariantCulture,
"({0} LIKE {1})",
propertyName,
expectedPropertyValueAsWqlWildcard);
return(condition);
}
/// <summary>
/// Modifies the query, so that it returns only objects that have a property value less than or equal to a <paramref name="maxPropertyValue"/> threshold
/// </summary>
/// <param name="propertyName">Property name to query on</param>
/// <param name="maxPropertyValue">Maximum property value</param>
/// <param name="behaviorOnNoMatch">
/// Describes how to handle filters that didn't match any objects
/// </param>
public override void FilterByMaxPropertyValue(string propertyName, object maxPropertyValue, BehaviorOnNoMatch behaviorOnNoMatch)
{
this.ClientSideQuery.FilterByMaxPropertyValue(propertyName, maxPropertyValue, behaviorOnNoMatch);
string wqlLiteral = CimQuery.ObjectToWqlLiteral(maxPropertyValue);
if (!string.IsNullOrWhiteSpace(wqlLiteral))
{
string condition = string.Format(
CultureInfo.InvariantCulture,
"{0} <= {1}",
propertyName,
CimQuery.ObjectToWqlLiteral(maxPropertyValue));
this.AddWqlCondition(condition);
}
}
internal QueryInstancesJob(CimJobContext jobContext, CimQuery cimQuery, string wqlCondition) : base(jobContext, cimQuery)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("SELECT * FROM ");
stringBuilder.Append(base.JobContext.ClassName);
stringBuilder.Append(" ");
stringBuilder.Append(wqlCondition);
this._wqlQuery = stringBuilder.ToString();
if (!string.IsNullOrWhiteSpace(wqlCondition))
{
if (jobContext.CmdletInvocationContext.CmdletDefinitionContext.UseEnumerateInstancesInsteadOfWql)
{
this._useEnumerateInstances = true;
}
return;
}
else
{
this._useEnumerateInstances = true;
return;
}
}
private static string GetMatchConditionForEqualityOperator(string propertyName, object propertyValue)
{
string condition;
// comparison of 'char' is case-sensitive in WQL (comparison of 'string' is case-insensitive)
if (propertyValue is char)
{
char c = (char)propertyValue;
char lowerCase = char.ToLowerInvariant(c);
char upperCase = char.ToUpperInvariant(c);
string lowerCaseLiteral = CimQuery.ObjectToWqlLiteral(lowerCase);
string upperCaseLiteral = CimQuery.ObjectToWqlLiteral(upperCase);
Dbg.Assert(!string.IsNullOrWhiteSpace(lowerCaseLiteral), "All characters are assumed to have valid WQL literals (lower)");
Dbg.Assert(!string.IsNullOrWhiteSpace(upperCaseLiteral), "All characters are assumed to have valid WQL literals (upper)");
condition = string.Format(
CultureInfo.InvariantCulture,
"(({0} = {1}) OR ({0} = {2}))",
propertyName,
lowerCaseLiteral,
upperCaseLiteral);
return(condition);
}
string wqlLiteral = CimQuery.ObjectToWqlLiteral(propertyValue);
if (string.IsNullOrWhiteSpace(wqlLiteral))
{
return(null);
}
condition = string.Format(
CultureInfo.InvariantCulture,
"({0} = {1})",
propertyName,
wqlLiteral);
return(condition);
}
internal QueryJobBase(CimJobContext jobContext, CimQuery cimQuery)
: base(jobContext)
{
Dbg.Assert(cimQuery != null, "Caller should verify cimQuery != null");
_cimQuery = cimQuery;
}
private static string ObjectToWqlLiteral(object o)
{
if (!LanguagePrimitives.IsNull(o))
{
o = CimValueConverter.ConvertFromDotNetToCim(o);
PSObject pSObject = PSObject.AsPSObject(o);
Type type = pSObject.BaseObject.GetType();
TypeCode typeCode = LanguagePrimitives.GetTypeCode(type);
if (typeCode != TypeCode.String)
{
if (typeCode != TypeCode.Char)
{
if (typeCode != TypeCode.DateTime)
{
if (type != typeof(TimeSpan))
{
if (!LanguagePrimitives.IsNumeric(typeCode))
{
if (!LanguagePrimitives.IsBooleanType(type))
{
throw CimValueConverter.GetInvalidCastException(null, "InvalidCimQueryCast", o, CmdletizationResources.CimConversion_WqlQuery);
}
else
{
if (!(bool)LanguagePrimitives.ConvertTo(o, typeof(bool), CultureInfo.InvariantCulture))
{
return("FALSE");
}
else
{
return("TRUE");
}
}
}
else
{
return((string)LanguagePrimitives.ConvertTo(o, typeof(string), CultureInfo.InvariantCulture));
}
}
else
{
return(null);
}
}
else
{
DateTime dateTime = (DateTime)LanguagePrimitives.ConvertTo(o, typeof(DateTime), CultureInfo.InvariantCulture);
string dmtfDateTime = ManagementDateTimeConverter.ToDmtfDateTime(dateTime);
return(string.Concat("'", dmtfDateTime, "'"));
}
}
else
{
return(CimQuery.ObjectToWqlLiteral(LanguagePrimitives.ConvertTo(o, typeof(string), CultureInfo.InvariantCulture)));
}
}
else
{
string str = o.ToString();
str = str.Replace("\\", "\\\\");
str = str.Replace("'", "\\'");
return(string.Concat("'", str, "'"));
}
}
else
{
return("null");
}
}
private static string WildcardToWqlLikeOperand(WildcardPattern wildcardPattern, out bool needsClientSideFiltering)
{
string str = WildcardPatternToCimQueryParser.Parse(wildcardPattern, out needsClientSideFiltering);
return(CimQuery.ObjectToWqlLiteral(str));
}
internal QueryJobBase(CimJobContext jobContext, CimQuery cimQuery) : base(jobContext)
{
this._cimQuery = cimQuery;
}
