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> /// 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 }); }
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)); }
/// <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"); } }