public ScanFilterCondition(string attributeName, ScanOperator scanOperator, List <AttributeValue> attributeValues)
{
this.AttributeName = attributeName;
this.Type = ScanFilterConditionType.two;
this.ScanOperator = scanOperator;
this.AttributeValues = attributeValues;
}
public async Task <string> FindMedicineNameByBarcode(long barcode)
{
ScanFilter scanFilter = new ScanFilter();
ScanOperator ope = ScanOperator.Equal;
string att = "Barcode";
scanFilter.AddCondition(att, ope, barcode);
Table table = Table.LoadTable(DynamoClient, "Medicine");
List <Document> medicine = await(table.Scan(scanFilter)).GetRemainingAsync();
int id = medicine.Count;
string val = "";
foreach (Document item in medicine)
{
foreach (string key in item.Keys)
{
if (key == "Name")
{
DynamoDBEntry dbEntry = item[key];
val = dbEntry.ToString();
}
}
}
return(val);
}
public async Task <byte[]> FindHashPasswordByUsername(string username)
{
ScanFilter filter = new ScanFilter();
ScanOperator op = ScanOperator.Equal;
string attrName = "Username";
filter.AddCondition(attrName, op, username);
Table tablename = Table.LoadTable(DynamoClient, "User");
List <Document> users = await(tablename.Scan(filter)).GetRemainingAsync();
int newID = users.Count;
byte[] password = Enumerable.Repeat((byte)0x20, 100).ToArray();;
string returnValue = "";
foreach (Document item in users)
{
foreach (string key in item.Keys)
{
if (key == "Password")
{
DynamoDBEntry dbEntry = item[key];
password = dbEntry.AsByteArray();
// returnValue = Encoding.ASCII.GetString(password);
//returnValue = Encoding.UTF8.GetString(password);
//string s = BitConverter.ToString(password);
}
}
}
return(password);
}
/// <summary>
/// Filters the items in a table by given predicate for a single property.
/// If there is an index over that property,
/// the scan operation will be made against that index.
/// </summary>
/// <param name="propertyExpression">
/// The lambda expression that extracts the property.
/// </param>
/// <param name="scanOperator">
/// A Amazon.DynamoDBv2.DocumentModel.ScanOperator.
/// </param>
/// <param name="value">
/// The value that should be matched by the filter over the given property.
/// </param>
public async Task <IEnumerable <TEntity> > FilterAsync <TProperty>(
Expression <Func <TEntity, TProperty> > propertyExpression,
ScanOperator scanOperator,
TProperty value)
{
InputValidator.ThrowIfAnyNull(propertyExpression, value);
var memberName = propertyExpression.TryGetMemberName();
var currentoperationConfig = this.operationConfig.Clone();
var indexName = this.indexExtractor.ExtractIndex <TEntity>(
memberName, this.entityConfig, this.table);
if (!string.IsNullOrWhiteSpace(indexName))
{
currentoperationConfig.IndexName = indexName;
}
var conditions = new List <ScanCondition>
{
new ScanCondition(memberName, scanOperator, value)
};
var asyncScan = this.Base.ScanAsync <TEntity>(conditions, currentoperationConfig);
return(await asyncScan.GetRemainingAsync());
}
public ScanFilterCondition(string attributeName, ScanOperator scanOperator, params DynamoDBEntry[] values)
{
this.AttributeName = attributeName;
this.Type = ScanFilterConditionType.three;
this.ScanOperator = scanOperator;
this.DynamoDBEntry = values;
}
private void AddScanFilterCondition(string name, ScanOperator operation, IEnumerable <object> values)
{
Primitive primitiveValue = null;
DynamoDBEntry[] primitiveValues = null;
if (values != null)
{
var valuesArray = values.ToArray();
if (valuesArray.Length == 1)
{
primitiveValue = converter.ToPrimative(valuesArray.First());
}
else
{
primitiveValues = valuesArray.Select(v => (DynamoDBEntry)converter.ToPrimative(v)).ToArray();
}
}
if (queryOperation == null && scanOperation == null)
{
scanOperation = new ScanOperationConfig();
if (indexName != null)
{
scanOperation.IndexName = indexName;
}
scanOperation.Filter = new ScanFilter();
}
if (queryOperation != null)
{
if (primitiveValue != null)
{
queryOperation.Filter.AddCondition(name, operation, primitiveValue);
}
else if (primitiveValues != null)
{
queryOperation.Filter.AddCondition(name, operation, primitiveValues);
}
else
{
queryOperation.Filter.AddCondition(name, operation, new DynamoDBEntry[] {});
}
}
else
{
if (primitiveValue != null)
{
scanOperation.Filter.AddCondition(name, operation, primitiveValue);
}
else if (primitiveValues != null)
{
scanOperation.Filter.AddCondition(name, operation, primitiveValues);
}
else
{
scanOperation.Filter.AddCondition(name, operation, new DynamoDBEntry[] {});
}
}
}
public void Reset()
{
skeyOp = ScanOperator.GTE;
ekeyOp = ScanOperator.LTE;
limitBy = ScanLimitBy.LimitResultSizeByte;
limit = 2 * 1024 * 1024;
skip_count = 0;
}
/// <summary>
/// Adds a condition for a specified attribute that consists
/// of an operator and any number of AttributeValues.
/// </summary>
/// <param name="attributeName">Target attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">AttributeValues to compare to</param>
public void AddCondition(string attributeName, ScanOperator op, List <AttributeValue> values)
{
AddCondition(attributeName, new Condition
{
ComparisonOperator = EnumToStringMapper.Convert(op),
AttributeValueList = values
});
}
/// <summary>
/// Adds a condition for a specified attribute that consists
/// of an operator and any number of values
/// </summary>
/// <param name="attributeName">Target attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">Values to compare to</param>
public void AddCondition(string attributeName, ScanOperator op, params DynamoDBEntry[] values)
{
AddCondition(attributeName, new Condition
{
ComparisonOperator = EnumToStringMapper.Convert(op),
AttributeValueList = ConvertToAttributeValues(values)
});
}
public void Clone(ScanFilterStruct sf)
{
skeyOp = sf.skeyOp;
ekeyOp = sf.ekeyOp;
limitBy = sf.limitBy;
limit = sf.limit;
skip_count = sf.skip_count;
}
public ScanFilterStruct(ScanOperator skop = ScanOperator.GTE, ScanOperator ekop = ScanOperator.LTE, ScanLimitBy _limitBy = ScanLimitBy.LimitResultSizeByte, int _limit = 0, int _skip_count = 0)
{
skeyOp = ScanOperator.GTE;
ekeyOp = ScanOperator.LTE;
limitBy = ScanLimitBy.LimitResultSizeByte;
limit = 2 * 1024 * 1024;
skip_count = 0;
}
public override void VisitScanOperator(ScanOperator node)
{
base.VisitScanOperator(node);
if (_position > node.WithKeyword.TextStart && node.DeclareClause != null)
{
_binder.AddDeclarationsToLocalScope(node.DeclareClause.Declarations);
_binder.AddStepDeclarationsToLocalScope(node);
}
}
public QueryModel(string fieldName, ScanOperator operatorType, params object[] values)
{
if (!values.Any())
{
throw new ArgumentException("Field is mandatory", nameof(values));
}
FieldName = fieldName ?? throw new ArgumentException("Field is mandatory", nameof(fieldName));
Values = values;
Operator = operatorType;
}
public IEnumerable <T> GetAllWithQuery(ScanOperator scanOperator, ConditionalOperatorValues?condition, params object[] values)
{
var config = new DynamoDBOperationConfig
{
OverrideTableName = _ddbTableName,
IndexName = IndexName,
};
config.QueryFilter.AddRange(new List <ScanCondition>
{
new ScanCondition("DateTimeId", scanOperator, values)
});
return(_ddbcontext.Query <T>(_applicationName, config));
}
public static string Convert(ScanOperator value)
{
switch (value)
{
case ScanOperator.Equal:
return("EQ");
case ScanOperator.NotEqual:
return("NE");
case ScanOperator.LessThanOrEqual:
return("LE");
case ScanOperator.LessThan:
return("LT");
case ScanOperator.GreaterThanOrEqual:
return("GE");
case ScanOperator.GreaterThan:
return("GT");
case ScanOperator.IsNotNull:
return("NOT_NULL");
case ScanOperator.IsNull:
return("NULL");
case ScanOperator.Contains:
return("CONTAINS");
case ScanOperator.NotContains:
return("NOT_CONTAINS");
case ScanOperator.BeginsWith:
return("BEGINS_WITH");
case ScanOperator.In:
return("IN");
case ScanOperator.Between:
return("BETWEEN");
default:
throw new ArgumentOutOfRangeException("Invalid ScanOperator value");
}
}
internal static ExpectedAttributeValue ToExpectedAttributeValue(bool exists, IEnumerable <DynamoDBEntry> values,
ScanOperator comparison, DynamoDBEntryConversion conversion, bool isEmptyStringValueEnabled)
{
var eav = new ExpectedAttributeValue();
if (exists)
{
eav.ComparisonOperator = EnumMapper.Convert(comparison);
foreach (var val in values)
{
var attributeConversionConfig = new DynamoDBEntry.AttributeConversionConfig(conversion, isEmptyStringValueEnabled);
eav.AttributeValueList.Add(val.ConvertToAttributeValue(attributeConversionConfig));
}
}
else
{
eav.Exists = exists;
}
return(eav);
}
//public async void FindMedicineWithBarcode(long barcode, string table)
//{
// GetItemOperationConfig config = new GetItemOperationConfig()
// {
// AttributesToGet = new List<string>() { "Barcode" },
// };
// // Primitive key = Medicine
// Table tablename = Table.LoadTable(DynamoClient, table);
// // tablename.GetItemAsync(Primitive Medicine.MedicineID, Primitive sortKey, GetItemOperationConfig config)
// ScanFilter scanFilter = new ScanFilter();
// scanFilter.AddCondition("Barcode", ScanOperator.Equal, barcode);
// ScanOperationConfig ScanConfig = new ScanOperationConfig()
// {
// AttributesToGet = new List<string> { "MedicineID", "Barcode" },
// Filter = scanFilter
// };
// Search getMedicine = tablename.Scan(ScanConfig);
// List<Document> result = await getMedicine.GetRemainingAsync();
// foreach (Document item in result)
// {
// foreach (string key in item.Keys)
// {
// DynamoDBEntry dbEntry = item[key];
// string val = dbEntry.ToString();
// if (key.ToLower() == "Barcode")
// {
// List<string> barcodes = dbEntry.AsListOfString();
// StringBuilder valueBuilder = new StringBuilder();
// foreach (string code in barcodes)
// {
// valueBuilder.Append(code).Append(", ");
// }
// val = valueBuilder.ToString();
// }
// Console.WriteLine(string.Format("Property: {0}, value: {1}", key, val));
// }
// }
//}
public async Task <string> FindPrescriptionForCurrentDate(string date)
{
ScanFilter filter = new ScanFilter();
ScanOperator op = ScanOperator.Equal;
string attrName = "StartDate";
filter.AddCondition(attrName, op, date);
Table tablename = Table.LoadTable(DynamoClient, "Prescription");
List <Document> prescriptions = await(tablename.Scan(filter)).GetRemainingAsync();
int newID = prescriptions.Count;
string medicineName = "";
string numberOfTime = "";
string returnValue = "";
foreach (Document item in prescriptions)
{
foreach (string key in item.Keys)
{
if (key == "Barcode")
{
DynamoDBEntry dbEntry = item[key];
string val = dbEntry.ToString();
long barcodeValue = Convert.ToInt64(val);
//find medicine name
medicineName = await FindMedicineNameByBarcode(barcodeValue);
}
if (key == "NumberOfTime")
{
DynamoDBEntry dbEntry = item[key];
numberOfTime = dbEntry.ToString();
}
returnValue = medicineName + " & " + numberOfTime;
}
}
return(returnValue);
}
private static bool TryConvertScanOperatorToQueryOperator(ScanOperator scanOperator, out QueryOperator result)
{
switch (scanOperator)
{
case ScanOperator.Equal:
result = QueryOperator.Equal;
break;
case ScanOperator.GreaterThan:
result = QueryOperator.GreaterThan;
break;
case ScanOperator.GreaterThanOrEqual:
result = QueryOperator.GreaterThanOrEqual;
break;
case ScanOperator.LessThan:
result = QueryOperator.LessThan;
break;
case ScanOperator.LessThanOrEqual:
result = QueryOperator.LessThanOrEqual;
break;
case ScanOperator.BeginsWith:
result = QueryOperator.BeginsWith;
break;
default:
{
result = QueryOperator.Equal;
return(false);
}
}
return(true);
}
/// <summary>
/// Adds an ExpectedValue with the specific Comparison and Values for the attribute.
/// </summary>
/// <param name="attributeName">Attribute that is being tested</param>
/// <param name="comparison">Comparison operator for the expected value.</param>
/// <param name="values">Values to compare the attribute against.</param>
public void AddExpected(string attributeName, ScanOperator comparison, params Primitive[] values)
{
ExpectedValues[attributeName] = new ExpectedValue(comparison, values);
}
/// <summary>
/// Adds a condition for a specified attribute that consists
/// of an operator and any number of values
/// </summary>
/// <param name="attributeName">Target attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">Values to compare to</param>
public void AddCondition(string attributeName, ScanOperator op, params DynamoDBEntry[] values)
{
AddCondition(attributeName, new Condition()
.WithComparisonOperator(EnumToStringMapper.Convert(op))
.WithAttributeValueList(ConvertToAttributeValues(values)));
}
/// <summary>
/// Adds a condition for a specified attribute that consists
/// of an operator and any number of values
/// </summary>
/// <param name="attributeName">Target attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">Values to compare to</param>
public void AddCondition(string attributeName, ScanOperator op, params DynamoDBEntry[] values)
{
AddCondition(attributeName, new Condition
{
ComparisonOperator = EnumToStringMapper.Convert(op),
AttributeValueList = ConvertToAttributeValues(values)
});
}
/// <summary>
/// Constructs an ExpectedValue with a given comparison and value(s).
/// </summary>
/// <param name="comparison"></param>
/// <param name="values"></param>
public ExpectedValue(ScanOperator comparison, params Primitive[] values)
{
Exists = true;
Comparison = comparison;
Values = new List<Primitive>(values);
}
/// <summary>
/// Initializes a ScanCondition with the target property, the
/// comparison operator and values being tested against.
/// </summary>
/// <param name="propertyName">Name of the property</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">
/// Value(s) being tested against.
///
/// The values should be of the same type as the property.
/// In the cases where the property is a collection, the values
/// should be of the same type as the items in the collection.
/// </param>
public ScanCondition(string propertyName, ScanOperator op, params object[] values)
{
PropertyName = propertyName;
Operator = op;
Values = values;
}
/// <summary>
/// Adds a condition for a specified non-key attribute that consists
/// of an operator and any number of values
/// </summary>
/// <param name="nonKeyAttributeName">Target non-key attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">Values to compare to</param>
public void AddCondition(string nonKeyAttributeName, ScanOperator op, params DynamoDBEntry[] values)
{
ComparisonOperator comparisonOperator = EnumMapper.Convert(op);
AddCondition(nonKeyAttributeName, comparisonOperator, values.ToList());
}
public SearchCondition(ScanOperator op, params DynamoDBEntry[] values)
{
this.Operator = op;
this.Values = values;
}
/// <summary>
/// Adds a condition for a specified non-key attribute that consists
/// of an operator and any number of values
/// </summary>
/// <param name="nonKeyAttributeName">Target non-key attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">Values to compare to</param>
public void AddCondition(string nonKeyAttributeName, ScanOperator op, params DynamoDBEntry[] values)
{
ComparisonOperator comparisonOperator= EnumMapper.Convert(op);
AddCondition(nonKeyAttributeName, comparisonOperator, values.ToList());
}
/// <summary>
/// Constructs an ExpectedValue with a given comparison and value(s).
/// </summary>
/// <param name="comparison"></param>
/// <param name="values"></param>
public ExpectedValue(ScanOperator comparison, params Primitive[] values)
{
Exists = true;
Comparison = comparison;
Values = new List <Primitive>(values);
}
public IEnumerable <T> GetAllWithQuery(ScanOperator scanOperator, ConditionalOperatorValues?condition, params object[] values)
{
Contract.Requires(values != null);
return(null);
}
private static Expression ScanOperatorToExpression(ScanOperator scanOperator, Expression operand1, Expression operand2)
{
switch (scanOperator)
{
case ScanOperator.Equal:
return Expression.Equal(operand1, operand2);
case ScanOperator.NotEqual:
return Expression.NotEqual(operand1, operand2);
case ScanOperator.LessThan:
if (operand1.Type == typeof(string))
{
return Expression.LessThan(Expression.Call(StringCompareMethodInfo, operand1, operand2, Expression.Constant(StringComparison.Ordinal)), Expression.Constant(0));
}
return Expression.LessThan(operand1, operand2);
case ScanOperator.LessThanOrEqual:
if (operand1.Type == typeof(string))
{
return Expression.LessThanOrEqual(Expression.Call(StringCompareMethodInfo, operand1, operand2, Expression.Constant(StringComparison.Ordinal)), Expression.Constant(0));
}
return Expression.LessThanOrEqual(operand1, operand2);
case ScanOperator.GreaterThan:
if (operand1.Type == typeof(string))
{
return Expression.GreaterThan(Expression.Call(StringCompareMethodInfo, operand1, operand2, Expression.Constant(StringComparison.Ordinal)), Expression.Constant(0));
}
return Expression.GreaterThan(operand1, operand2);
case ScanOperator.GreaterThanOrEqual:
if (operand1.Type == typeof(string))
{
return Expression.GreaterThanOrEqual(Expression.Call(StringCompareMethodInfo, operand1, operand2, Expression.Constant(StringComparison.Ordinal)), Expression.Constant(0));
}
return Expression.GreaterThanOrEqual(operand1, operand2);
case ScanOperator.BeginsWith:
if (operand1.Type == typeof (string))
{
return Expression.Call(operand1, StartsWithMethodInfo, operand2);
}
break;
case ScanOperator.Contains:
if (operand1.Type == typeof(string))
{
return Expression.Call(operand1, ContainsMethodInfo, operand2);
}
break;
case ScanOperator.NotContains:
if (operand1.Type == typeof(string))
{
return Expression.Not(Expression.Call(operand1, ContainsMethodInfo, operand2));
}
break;
}
throw new NotSupportedException(string.Format("Condition operator {0} is not supported", scanOperator));
}
private static Expression ScanOperatorToExpression(ScanOperator scanOperator, Expression operand1, Expression operand2)
{
switch (scanOperator)
{
case ScanOperator.Equal:
return(Expression.Equal(operand1, operand2));
case ScanOperator.NotEqual:
return(Expression.NotEqual(operand1, operand2));
case ScanOperator.LessThan:
if (operand1.Type == typeof(string))
{
return(Expression.LessThan(Expression.Call(StringCompareMethodInfo, operand1, operand2, Expression.Constant(StringComparison.Ordinal)), Expression.Constant(0)));
}
return(Expression.LessThan(operand1, operand2));
case ScanOperator.LessThanOrEqual:
if (operand1.Type == typeof(string))
{
return(Expression.LessThanOrEqual(Expression.Call(StringCompareMethodInfo, operand1, operand2, Expression.Constant(StringComparison.Ordinal)), Expression.Constant(0)));
}
return(Expression.LessThanOrEqual(operand1, operand2));
case ScanOperator.GreaterThan:
if (operand1.Type == typeof(string))
{
return(Expression.GreaterThan(Expression.Call(StringCompareMethodInfo, operand1, operand2, Expression.Constant(StringComparison.Ordinal)), Expression.Constant(0)));
}
return(Expression.GreaterThan(operand1, operand2));
case ScanOperator.GreaterThanOrEqual:
if (operand1.Type == typeof(string))
{
return(Expression.GreaterThanOrEqual(Expression.Call(StringCompareMethodInfo, operand1, operand2, Expression.Constant(StringComparison.Ordinal)), Expression.Constant(0)));
}
return(Expression.GreaterThanOrEqual(operand1, operand2));
case ScanOperator.BeginsWith:
if (operand1.Type == typeof(string))
{
return(Expression.Call(operand1, StartsWithMethodInfo, operand2));
}
break;
case ScanOperator.Contains:
if (operand1.Type == typeof(string))
{
return(Expression.Call(operand1, ContainsMethodInfo, operand2));
}
break;
case ScanOperator.NotContains:
if (operand1.Type == typeof(string))
{
return(Expression.Not(Expression.Call(operand1, ContainsMethodInfo, operand2)));
}
break;
}
throw new NotSupportedException(string.Format("Condition operator {0} is not supported", scanOperator));
}
private static bool TryConvertScanOperatorToQueryOperator(ScanOperator scanOperator, out QueryOperator result)
{
switch (scanOperator)
{
case ScanOperator.Equal:
result = QueryOperator.Equal;
break;
case ScanOperator.GreaterThan:
result = QueryOperator.GreaterThan;
break;
case ScanOperator.GreaterThanOrEqual:
result = QueryOperator.GreaterThanOrEqual;
break;
case ScanOperator.LessThan:
result = QueryOperator.LessThan;
break;
case ScanOperator.LessThanOrEqual:
result = QueryOperator.LessThanOrEqual;
break;
case ScanOperator.BeginsWith:
result = QueryOperator.BeginsWith;
break;
default:
{
result = QueryOperator.Equal;
return false;
}
}
return true;
}
public void AddSearchCriteria(string propertyName, object value, ScanOperator criteriaOperator = ScanOperator.Equal)
{
SearchCriteria.Add(new DynamoScanSearchCriteriaEntity {
PropertyName = propertyName, Value = value, ScanOperator = criteriaOperator
});
}
/// <summary>
/// Adds an ExpectedValue with the specific Comparison and Values for the attribute.
/// </summary>
/// <param name="attributeName">Attribute that is being tested</param>
/// <param name="comparison">Comparison operator for the expected value.</param>
/// <param name="values">Values to compare the attribute against.</param>
public void AddExpected(string attributeName, ScanOperator comparison, params Primitive[] values)
{
ExpectedValues[attributeName] = new ExpectedValue(comparison, values);
}
public IActionResult Execute([FromBody] string logicalPlanJson)
{
if (host == null)
{
host = SiloWrapper.Instance.host;
}
if (client == null)
{
client = ClientWrapper.Instance.client;
}
Stream req = Request.Body;
req.Seek(0, System.IO.SeekOrigin.Begin);
string json = new StreamReader(req).ReadToEnd();
//apply TPC-H Query-1
//json="{\"logicalPlan\":{\"operators\":[{\"tableName\":\"<file>\",\"operatorID\":\"operator-3bc05014-357d-45f5-a053-9baf1a62bd27\",\"operatorType\":\"ScanSource\"},{\"attributeName\":\"_c10\",\"attributeType\":\"date\",\"comparisonType\":\">\",\"compareTo\":\"1991-01-01\",\"operatorID\":\"operator-345a8b3d-2b1b-485e-b7c1-1cd9f579ce4f\",\"operatorType\":\"Comparison\"},{\"groupByAttribute\":\"_c8\",\"aggregationAttribute\":\"_c4\",\"aggregationFunction\":\"sum\",\"operatorID\":\"operator-89854b72-7c28-436b-b162-ead3daa75f72\",\"operatorType\":\"GroupBy\"},{\"attributeName\":\"_c0\",\"attributeType\":\"string\",\"operatorID\":\"operator-c7d7e79c-49ca-46a4-8420-490c25cd052d\",\"operatorType\":\"InsertionSort\"}],\"links\":[{\"origin\":\"operator-3bc05014-357d-45f5-a053-9baf1a62bd27\",\"destination\":\"operator-345a8b3d-2b1b-485e-b7c1-1cd9f579ce4f\"},{\"origin\":\"operator-345a8b3d-2b1b-485e-b7c1-1cd9f579ce4f\",\"destination\":\"operator-89854b72-7c28-436b-b162-ead3daa75f72\"},{\"origin\":\"operator-89854b72-7c28-436b-b162-ead3daa75f72\",\"destination\":\"operator-c7d7e79c-49ca-46a4-8420-490c25cd052d\"}]},\"workflowID\":\"texera-workflow-824ec494-8f6c-41a3-a3c0-29ca6dc7fe97\"}";
Console.WriteLine("JSON BODY = " + json);
Dictionary <string, Operator> map = new Dictionary <string, Operator>();
JObject o = JObject.Parse(json);
JArray operators = (JArray)o["logicalPlan"]["operators"];
Guid workflowID;
//remove "texera-workflow-" at the begining of workflowID to make it parsable
if (!Guid.TryParse(o["workflowID"].ToString().Substring(16), out workflowID))
{
throw new Exception($"Parse workflowID failed! For {o["workflowID"].ToString().Substring(16)}");
}
Workflow workflow = new Workflow(workflowID);
int table_id = 0;
foreach (JObject operator1 in operators)
{
Operator op = null;
if ((string)operator1["operatorType"] == "ScanSource")
{
//example path to HDFS through WebHDFS API: "http://localhost:50070/webhdfs/v1/input/very_large_input.csv"
ScanPredicate scanPredicate = new ScanPredicate((string)operator1["tableName"], table_id++);
op = new ScanOperator(scanPredicate);
}
else if ((string)operator1["operatorType"] == "KeywordMatcher")
{
KeywordPredicate keywordPredicate = new KeywordPredicate(int.Parse(operator1["attributeName"].ToString().Replace("_c", "")), operator1["keyword"] != null?operator1["keyword"].ToString():"");
op = new KeywordOperator(keywordPredicate);
}
else if ((string)operator1["operatorType"] == "Aggregation")
{
CountPredicate countPredicate = new CountPredicate();
op = new CountOperator(countPredicate);
}
else if ((string)operator1["operatorType"] == "Comparison")
{
FilterPredicate filterPredicate = new FilterPredicate(int.Parse(operator1["attributeName"].ToString().Replace("_c", "")), operator1["compareTo"].ToString(), operator1["comparisonType"].ToString());
switch (operator1["attributeType"].ToString())
{
case "int":
op = new FilterOperator <int>(filterPredicate);
break;
case "double":
op = new FilterOperator <double>(filterPredicate);
break;
case "date":
op = new FilterOperator <DateTime>(filterPredicate);
break;
case "string":
op = new FilterOperator <string>(filterPredicate);
break;
}
}
else if ((string)operator1["operatorType"] == "CrossRippleJoin")
{
int inputLimit = operator1["batchingLimit"] == null?1000:int.Parse(operator1["batchingLimit"].ToString());
CrossRippleJoinPredicate crossRippleJoinPredicate = new CrossRippleJoinPredicate(table_id++, inputLimit);
op = new CrossRippleJoinOperator(crossRippleJoinPredicate);
}
else if ((string)operator1["operatorType"] == "HashRippleJoin")
{
HashRippleJoinPredicate hashRippleJoinPredicate = new HashRippleJoinPredicate(int.Parse(operator1["attributeName"].ToString().Replace("_c", "")), table_id++);
op = new HashRippleJoinOperator(hashRippleJoinPredicate);
}
else if ((string)operator1["operatorType"] == "InsertionSort")
{
SortPredicate sortPredicate = new SortPredicate(int.Parse(operator1["attributeName"].ToString().Replace("_c", "")));
switch (operator1["attributeType"].ToString())
{
case "int":
op = new SortOperator <int>(sortPredicate);
break;
case "double":
op = new SortOperator <double>(sortPredicate);
break;
case "date":
op = new SortOperator <DateTime>(sortPredicate);
break;
case "string":
op = new SortOperator <string>(sortPredicate);
break;
}
}
else if ((string)operator1["operatorType"] == "GroupBy")
{
int groupByIndex = int.Parse(operator1["groupByAttribute"].ToString().Replace("_c", ""));
int aggregationIndex = int.Parse(operator1["aggregationAttribute"].ToString().Replace("_c", ""));
GroupByPredicate groupByPredicate = new GroupByPredicate(groupByIndex, aggregationIndex, operator1["aggregationFunction"].ToString());
op = new GroupByOperator(groupByPredicate);
}
else if ((string)operator1["operatorType"] == "Projection")
{
List <int> projectionIndexs = operator1["projectionAttributes"].ToString().Split(",").Select(x => int.Parse(x.Replace("_c", ""))).ToList();
ProjectionPredicate projectionPredicate = new ProjectionPredicate(projectionIndexs);
op = new ProjectionOperator(projectionPredicate);
}
else if ((string)operator1["operatorType"] == "HashJoin")
{
HashJoinPredicate hashJoinPredicate = new HashJoinPredicate(int.Parse(operator1["attributeName"].ToString().Replace("_c", "")), table_id++);
op = new HashJoinOperator(hashJoinPredicate);
}
if (op != null)
{
map.Add((string)operator1["operatorID"], op);
}
}
JArray links = (JArray)o["logicalPlan"]["links"];
foreach (JObject link in links)
{
Operator origin = map[(string)link["origin"]];
Operator dest = map[(string)link["destination"]];
origin.AddOutOperator(dest);
dest.AddInOperator(origin);
}
workflow.InitializeOperatorSet(new HashSet <Operator>(map.Values));
List <TexeraTuple> results = ClientWrapper.Instance.DoClientWork(client, workflow).Result;
if (results == null)
{
results = new List <TexeraTuple>();
}
List <JObject> resultJson = new List <JObject>();
foreach (TexeraTuple tuple in results)
{
JObject jsonTuple = new JObject();
jsonTuple.Add("TableID", tuple.TableID);
for (int i = 0; i < tuple.FieldList.Length; ++i)
{
jsonTuple.Add("_c" + i, tuple.FieldList[i]);
}
resultJson.Add(jsonTuple);
}
TexeraResult texeraResult = new TexeraResult();
texeraResult.code = 0;
texeraResult.result = resultJson;
texeraResult.resultID = Guid.NewGuid();
return(Json(texeraResult));
}
/// <summary>
/// Adds a condition for a specified attribute that consists
/// of an operator and any number of AttributeValues.
/// </summary>
/// <param name="attributeName">Target attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">AttributeValues to compare to</param>
public void AddCondition(string attributeName, ScanOperator op, List<AttributeValue> values)
{
AddCondition(attributeName, new Condition
{
ComparisonOperator = EnumToStringMapper.Convert(op),
AttributeValueList = values
});
}
public override ScalarValue VisitScanOperator(ScanOperator node)
{
throw new NotImplementedException();
}
/// <summary>
/// Adds a condition for a specified attribute that consists
/// of an operator and any number of AttributeValues.
/// </summary>
/// <param name="attributeName">Target attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">AttributeValues to compare to</param>
public void AddCondition(string attributeName, ScanOperator op, List <AttributeValue> values)
{
AddCondition(attributeName, new Condition()
.WithComparisonOperator(EnumToStringMapper.Convert(op))
.WithAttributeValueList(values));
}
public SearchCondition(ScanOperator op, params DynamoDBEntry[] values)
{
this.Operator = op;
this.Values = values;
}
/// <summary>
/// Adds a condition for a specified attribute that consists
/// of an operator and any number of AttributeValues.
/// </summary>
/// <param name="attributeName">Target attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">AttributeValues to compare to</param>
public void AddCondition(string attributeName, ScanOperator op, List<AttributeValue> values)
{
AddCondition(attributeName, new Condition()
.WithComparisonOperator(EnumToStringMapper.Convert(op))
.WithAttributeValueList(values));
}
public static string Convert(ScanOperator value)
{
switch (value)
{
case ScanOperator.Equal:
return "EQ";
case ScanOperator.NotEqual:
return "NE";
case ScanOperator.LessThanOrEqual:
return "LE";
case ScanOperator.LessThan:
return "LT";
case ScanOperator.GreaterThanOrEqual:
return "GE";
case ScanOperator.GreaterThan:
return "GT";
case ScanOperator.IsNotNull:
return "NOT_NULL";
case ScanOperator.IsNull:
return "NULL";
case ScanOperator.Contains:
return "CONTAINS";
case ScanOperator.NotContains:
return "NOT_CONTAINS";
case ScanOperator.BeginsWith:
return "BEGINS_WITH";
case ScanOperator.In:
return "IN";
case ScanOperator.Between:
return "BETWEEN";
default:
throw new ArgumentOutOfRangeException("Invalid ScanOperator value");
}
}
/// <summary>
/// Initializes a ScanCondition with the target property, the
/// comparison operator and values being tested against.
/// </summary>
/// <param name="propertyName">Name of the property</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">
/// Value(s) being tested against.
///
/// The values should be of the same type as the property.
/// In the cases where the property is a collection, the values
/// should be of the same type as the items in the collection.
/// </param>
public ScanCondition(string propertyName, ScanOperator op, params object[] values)
{
PropertyName = propertyName;
Operator = op;
Values = values;
}
/// <summary>
/// Adds a condition for a specified attribute that consists
/// of an operator and any number of values
/// </summary>
/// <param name="attributeName">Target attribute name</param>
/// <param name="op">Comparison operator</param>
/// <param name="values">Values to compare to</param>
public void AddCondition(string attributeName, ScanOperator op, params DynamoDBEntry[] values)
{
AddCondition(attributeName, new Condition()
.WithComparisonOperator(EnumToStringMapper.Convert(op))
.WithAttributeValueList(ConvertToAttributeValues(values)));
}
