public void TestQueryGroupWithSingleFieldWithConjunctionOrAndWithChildQueryGroupWithTwoFieldsAndWithConjunctionOr()
{
// Setup
var childQueryGroup = new QueryGroup(new[]
{
new QueryField("Field2", Operation.Equal, 2),
new QueryField("Field3", Operation.Equal, 3)
},
Conjunction.Or);
var queryGroup = new QueryGroup(new QueryField("Field1", 1).AsEnumerable(),
childQueryGroup.AsEnumerable(),
Conjunction.Or);
// Act
var actual = queryGroup.GetString(m_dbSetting);
var expected = "([Field1] = @Field1 OR ([Field2] = @Field2 OR [Field3] = @Field3))";
// Assert
Assert.AreEqual(expected, actual);
}
public void TestSqLiteConnectionDeleteAsyncViaQueryGroup()
{
using (var connection = new SqliteConnection(Database.ConnectionStringMDS))
{
// Setup
var tables = Database.CreateMdsCompleteTables(10, connection);
var queryFields = new[]
{
new QueryField("Id", Operation.GreaterThan, tables.First().Id),
new QueryField("Id", Operation.LessThan, tables.Last().Id)
};
var queryGroup = new QueryGroup(queryFields);
// Act
var result = connection.DeleteAsync <MdsCompleteTable>(queryGroup).Result;
// Assert
Assert.AreEqual(8, result);
}
}
/// <summary>
/// Creates a new instance of <see cref="BatchQueryRequest"/> object.
/// </summary>
/// <param name="name">The name of the request.</param>
/// <param name="connection">The connection object.</param>
/// <param name="fields">The list of the target fields.</param>
/// <param name="page">The page of the batch.</param>
/// <param name="rowsPerBatch">The number of rows per batch.</param>
/// <param name="orderBy">The list of order fields.</param>
/// <param name="where">The query expression.</param>
/// <param name="hints">The hints for the table.</param>
/// <param name="statementBuilder">The statement builder.</param>
public BatchQueryRequest(string name,
IDbConnection connection,
IEnumerable <Field> fields,
int page,
int rowsPerBatch,
IEnumerable <OrderField> orderBy,
QueryGroup where = null,
string hints = null,
IStatementBuilder statementBuilder = null)
: base(name,
connection,
statementBuilder)
{
Fields = fields;
Where = where;
Page = page;
RowsPerBatch = rowsPerBatch;
OrderBy = orderBy;
Hints = hints;
}
public void TestPostgreSqlConnectionDeleteViaQueryGroup()
{
// Setup
var tables = Database.CreateCompleteTables(10);
var queryFields = new[]
{
new QueryField("Id", Operation.GreaterThan, tables.First().Id),
new QueryField("Id", Operation.LessThan, tables.Last().Id)
};
var queryGroup = new QueryGroup(queryFields);
using (var connection = new NpgsqlConnection(Database.ConnectionString))
{
// Act
var result = connection.Delete <CompleteTable>(queryGroup);
// Assert
Assert.AreEqual(8, result);
}
}
public void TestSqLiteConnectionExistsViaQueryGroup()
{
using (var connection = new SQLiteConnection(Database.ConnectionStringSDS))
{
// Setup
var tables = Database.CreateSdsCompleteTables(10, connection);
var queryFields = new[]
{
new QueryField("Id", Operation.GreaterThan, tables.First().Id),
new QueryField("Id", Operation.LessThan, tables.Last().Id)
};
var queryGroup = new QueryGroup(queryFields);
// Act
var result = connection.Exists <SdsCompleteTable>(queryGroup);
// Assert
Assert.IsTrue(result);
}
}
public void TestSqlServerConnectionExistsAsyncViaQueryGroup()
{
// Setup
var tables = Database.CreateCompleteTables(10);
var queryFields = new[]
{
new QueryField("Id", Operation.GreaterThan, tables.First().Id),
new QueryField("Id", Operation.LessThan, tables.Last().Id)
};
var queryGroup = new QueryGroup(queryFields);
using (var connection = new SqlConnection(Database.ConnectionString))
{
// Act
var result = connection.ExistsAsync <CompleteTable>(queryGroup).Result;
// Assert
Assert.IsTrue(result);
}
}
public void TestQueryGroupObjectEqualityViaEqualMethodWithMultipleFieldsForQueryFieldsWithSameConjunction()
{
// Prepare
var objA = new QueryGroup(new[]
{
new QueryField("Id", 1),
new QueryField("Name", "Name1")
}, Conjunction.And);
var objB = new QueryGroup(new[]
{
new QueryField("Id", 2),
new QueryField("Name", "Name2")
}, Conjunction.And);
// Act
var equal = Equals(objA, objB);
// Assert
Assert.IsTrue(equal);
}
public void TestMySqlConnectionQueryAsyncViaTableNameViaQueryGroup()
{
// Setup
var table = Database.CreateCompleteTables(1).First();
var queryFields = new[]
{
new QueryField("Id", table.Id),
new QueryField("ColumnInt", table.ColumnInt)
};
var queryGroup = new QueryGroup(queryFields);
using (var connection = new MySqlConnection(Database.ConnectionString))
{
// Act
var result = connection.QueryAsync(ClassMappedNameCache.Get <CompleteTable>(), queryGroup).Result.First();
// Assert
Helper.AssertMembersEquality(table, result);
}
}
public void TestQueryGroupObjectEqualityWithMultipleFieldsForQueryFieldsWithDifferentConjunction()
{
// Prepare
var objA = new QueryGroup(new[]
{
new QueryField("Id", 1),
new QueryField("Name", "Name1")
}, Conjunction.And);
var objB = new QueryGroup(new[]
{
new QueryField("Id", 2),
new QueryField("Name", "Name2")
}, Conjunction.Or);
// Act
var equal = (objA == objB);
// Assert
Assert.IsFalse(equal);
}
public void TestQueryGroupObjectEqualityWithMultipleFieldsForQueryFieldsWithSameIsNot()
{
// Prepare
var objA = new QueryGroup(new[]
{
new QueryField("Id", 1),
new QueryField("Name", "Name1")
}, true);
var objB = new QueryGroup(new[]
{
new QueryField("Id", 2),
new QueryField("Name", "Name2")
}, true);
// Act
var equal = (objA == objB);
// Assert
Assert.IsTrue(equal);
}
public void TestQueryGroupHashCodeEqualityWithMultipleFieldsForQueryFieldsWithSameConjunction()
{
// Prepare
var objA = new QueryGroup(new[]
{
new QueryField("Id", 1),
new QueryField("Name", "Name1")
}, Conjunction.And);
var objB = new QueryGroup(new[]
{
new QueryField("Id", 2),
new QueryField("Name", "Name2")
}, Conjunction.And);
// Act
var equal = (objA.GetHashCode() == objB.GetHashCode());
// Assert
Assert.IsTrue(equal);
}
public void TestQueryGroupHashCodeEqualityWithMultipleFieldsForQueryFieldsWithDifferentIsNot()
{
// Prepare
var objA = new QueryGroup(new[]
{
new QueryField("Id", 1),
new QueryField("Name", "Name1")
}, true);
var objB = new QueryGroup(new[]
{
new QueryField("Id", 2),
new QueryField("Name", "Name2")
}, false);
// Act
var equal = (objA.GetHashCode() == objB.GetHashCode());
// Assert
Assert.IsFalse(equal);
}
public void TestSqLiteConnectionCountViaQueryGroup()
{
using (var connection = new SQLiteConnection(Database.ConnectionStringSDS))
{
// Setup
var tables = Database.CreateSdsCompleteTables(10, connection);
var queryFields = new[]
{
new QueryField("Id", Operation.GreaterThan, tables.First().Id),
new QueryField("Id", Operation.LessThan, tables.Last().Id)
};
var queryGroup = new QueryGroup(queryFields);
// Act
var result = connection.Count <SdsCompleteTable>(queryGroup);
// Assert
Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id&& e.Id < tables.Last().Id).Count(), result);
}
}
public void TestChildQueryGroupsSingle()
{
// Setup
var expression = new
{
Field1 = 1,
QueryGroups = new
{
Field2 = 2,
Field3 = 3
}
};
// Act
var actual = QueryGroup.Parse(expression).GetString();
var expected = $"([Field1] = @Field1 AND ([Field2] = @Field2 AND [Field3] = @Field3))";
// Assert
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Creates a new instance of <see cref="QueryMultipleRequest"/> object.
/// </summary>
/// <param name="index">The index value.</param>
/// <param name="name">The name of the request.</param>
/// <param name="connection">The connection object.</param>
/// <param name="fields">The list of the target fields.</param>
/// <param name="where">The query expression.</param>
/// <param name="orderBy">The list of order fields.</param>
/// <param name="top">The filter for the rows.</param>
/// <param name="hints">The hints for the table.</param>
/// <param name="statementBuilder">The statement builder.</param>
public QueryMultipleRequest(int?index,
string name,
IDbConnection connection,
IEnumerable <Field> fields = null,
QueryGroup where = null,
IEnumerable <OrderField> orderBy = null,
int?top = null,
string hints = null,
IStatementBuilder statementBuilder = null)
: base(name,
connection,
statementBuilder)
{
Index = index;
Fields = fields;
Where = where;
OrderBy = orderBy;
Top = top;
Hints = hints;
}
public void TestMySqlConnectionDeleteAsyncViaTableNameViaQueryGroup()
{
// Setup
var tables = Database.CreateCompleteTables(10);
var queryFields = new[]
{
new QueryField("Id", Operation.GreaterThan, tables.First().Id),
new QueryField("Id", Operation.LessThan, tables.Last().Id)
};
var queryGroup = new QueryGroup(queryFields);
using (var connection = new MySqlConnection(Database.ConnectionString))
{
// Act
var result = connection.DeleteAsync(ClassMappedNameCache.Get <CompleteTable>(), queryGroup).Result;
// Assert
Assert.AreEqual(8, result);
}
}
public void TestQueryGroupObjectEqualityViaEqualMethodWithMultipleFieldsForQueryFieldsWithDifferentIsNot()
{
// Prepare
var objA = new QueryGroup(new[]
{
new QueryField("Id", 1),
new QueryField("Name", "Name1")
}, true);
var objB = new QueryGroup(new[]
{
new QueryField("Id", 2),
new QueryField("Name", "Name2")
}, false);
// Act
var equal = Equals(objA, objB);
// Assert
Assert.IsFalse(equal);
}
public void TestMySqlConnectionQueryViaQueryGroup()
{
// Setup
var table = Database.CreateCompleteTables(1).First();
var queryFields = new[]
{
new QueryField("Id", table.Id),
new QueryField("ColumnInt", table.ColumnInt)
};
var queryGroup = new QueryGroup(queryFields);
using (var connection = new MySqlConnection(Database.ConnectionString))
{
// Act
var result = connection.Query <CompleteTable>(queryGroup).First();
// Assert
Helper.AssertPropertiesEquality(table, result);
}
}
/// <summary>
/// Creates a new instance of <see cref="QueryRequest"/> object.
/// </summary>
/// <param name="name">The name of the request.</param>
/// <param name="connection">The connection object.</param>
/// <param name="transaction">The transaction object.</param>
/// <param name="fields">The list of the target fields.</param>
/// <param name="where">The query expression.</param>
/// <param name="orderBy">The list of order fields.</param>
/// <param name="top">The filter for the rows.</param>
/// <param name="hints">The hints for the table.</param>
/// <param name="statementBuilder">The statement builder.</param>
public QueryRequest(string name,
IDbConnection connection,
IDbTransaction transaction,
IEnumerable <Field> fields = null,
QueryGroup where = null,
IEnumerable <OrderField> orderBy = null,
int?top = null,
string hints = null,
IStatementBuilder statementBuilder = null)
: base(name,
connection,
transaction,
statementBuilder)
{
Fields = fields;
Where = where;
OrderBy = orderBy;
Top = top;
Hints = hints;
}
public void TestSqLiteConnectionQueryAsyncViaQueryGroup()
{
using (var connection = new SQLiteConnection(Database.ConnectionStringSDS))
{
// Setup
var table = Database.CreateSdsCompleteTables(1, connection).First();
var queryFields = new[]
{
new QueryField("Id", table.Id),
new QueryField("ColumnInt", table.ColumnInt)
};
var queryGroup = new QueryGroup(queryFields);
// Act
var result = connection.QueryAsync <SdsCompleteTable>(queryGroup).Result.First();
// Assert
Helper.AssertPropertiesEquality(table, result);
}
}
/// <summary>
/// Merge the <see cref="QueryGroup"/> object into the current object.
/// </summary>
/// <param name="obj">The object where the <see cref="QueryGroup"/> object will be merged.</param>
/// <param name="properties">The list of <see cref="PropertyInfo"/> objects.</param>
/// <param name="queryGroup">The <see cref="QueryGroup"/> object to merged.</param>
/// <param name="dbSetting">The database setting that is currently in used.</param>
/// <returns>The object instance itself with the merged values.</returns>
internal static object Merge(this object obj,
IEnumerable <PropertyInfo> properties,
QueryGroup queryGroup,
IDbSetting dbSetting)
{
var expandObject = new ExpandoObject() as IDictionary <string, object>;
foreach (var property in properties)
{
expandObject[PropertyMappedNameCache.Get(property, false, dbSetting)] = property.GetValue(obj);
}
if (queryGroup != null)
{
foreach (var queryField in queryGroup?.Fix().GetFields(true))
{
expandObject[queryField.Parameter.Name] = queryField.Parameter.Value;
}
}
return((ExpandoObject)expandObject);
}
public async Task <IQueryable <B2CProduct> > GetAllAsync(int pageSize, int pageIndex, CancellationTokenSource token)
{
try
{
int startPage = (pageSize * (pageIndex - 1)), endPage = startPage + pageSize;
startPage += 1;
using (var connection = new SqlConnection(ConnectionString).EnsureOpen())
{
var commandText = "select * from (select ROW_NUMBER() over(order by[IdProduct] asc) as rn, * FROM [dbo].[B2CProduct] WITH (NOLOCK) WHERE IsActive = 1) as x where rn between @startPage and @endPage";
var param = new QueryGroup(new[]
{
new QueryField("startPage", startPage),
new QueryField("endPage", endPage)
});
// Execute the SQL
var products = await connection.ExecuteQueryAsync <B2CProduct>(commandText, param);
if (products.Any())
{
commandText = "SELECT * FROM [dbo].[B2CImage] WITH (NOLOCK) WHERE IdOffer is null and IdProduct IN (@Keys);";
param = new QueryGroup(new QueryField("Keys", products.Select(w => w.IdProduct).ToArray()));
var images = await connection.ExecuteQueryAsync <B2CImage>(commandText, param);
foreach (var product in products)
{
product.B2CImage = images.Where(x => x.IdProduct == product.IdProduct).ToList();
}
}
return(products.AsQueryable());
}
}
catch (Exception exc)
{
token.Cancel(true);
string mensaje = String.Format(MessagesInfraestructure.ErrorGetByKeyAsync, "en Repositorio base");
throw new InfraestructureExcepcion(mensaje, exc);
}
}
public void When_the_group_has_only_subgroups_should_return_the_predicate_based_on_them()
{
// Arrange - and example
var group1 = new QueryGroup();
group1.Rules.Add(new QueryRule("Number", FieldOperation.Equal, "20"));
group1.Rules.Add(new QueryRule("Text", FieldOperation.Contains, "ane"));
var group2 = new QueryGroup();
group2.Rules.Add(new QueryRule("Number", FieldOperation.Equal, "3"));
// Arrange - or example
var group3 = new QueryGroup();
group3.Rules.Add(new QueryRule("Number", FieldOperation.Equal, "20"));
group3.Rules.Add(new QueryRule("Text", FieldOperation.Contains, "ane"));
var group4 = new QueryGroup();
group4.LogicalOperation = LogicalOperation.Or;
group4.Rules.Add(new QueryRule("Number", FieldOperation.Equal, "3"));
// Act
var resultAnd = queryBuilder.BuildGroupPredicate(
new QueryGroup {
InnerGroups = new List <QueryGroup> {
group1, group2
}
});
var resultOr = queryBuilder.BuildGroupPredicate(
new QueryGroup {
InnerGroups = new List <QueryGroup> {
group3, group4
}
});
// Assert
Assert.Equal(_testData.Count(x => (x.Number == 5 && x.Text.Contains("ane")) && x.Number == 20), _testData.Count(x => resultAnd(x)));
Assert.Equal(_testData.Count(x => (x.Number == 5 && x.Text.Contains("ane")) || x.Number == 20), _testData.Count(x => resultOr(x)));
}
/// <summary>
/// Creates a SQL Statement for query operation.
/// </summary>
/// <param name="queryBuilder">The query builder to be used.</param>
/// <param name="tableName">The name of the target table.</param>
/// <param name="fields">The list of fields.</param>
/// <param name="where">The query expression.</param>
/// <param name="orderBy">The list of fields for ordering.</param>
/// <param name="top">The number of rows to be returned.</param>
/// <param name="hints">The table hints to be used.</param>
/// <returns>A sql statement for query operation.</returns>
public override string CreateQuery(QueryBuilder queryBuilder,
string tableName,
IEnumerable <Field> fields,
QueryGroup where = null,
IEnumerable <OrderField> orderBy = null,
int?top = null,
string hints = null)
{
// Ensure with guards
GuardTableName(tableName);
// Validate the hints
GuardHints(hints);
// There should be fields
if (fields?.Any() != true)
{
throw new NullReferenceException($"The list of queryable fields must not be null for '{tableName}'.");
}
// Initialize the builder
var builder = queryBuilder ?? new QueryBuilder();
// Build the query
builder.Clear()
.Select()
.FieldsFrom(fields, DbSetting)
.From()
.TableNameFrom(tableName, DbSetting)
.HintsFrom(hints)
.WhereFrom(where, DbSetting)
.OrderByFrom(orderBy, DbSetting);
if (top > 0)
{
builder.Limit(top);
}
builder.End();
// Return the query
return(builder.GetString());
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="where"></param>
/// <param name="dbFields"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
private static UpdateExecutionContext <TEntity> CreateInternal <TEntity>(IDbConnection connection,
string tableName,
QueryGroup where,
IEnumerable <DbField> dbFields,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
where TEntity : class
{
var dbSetting = connection.GetDbSetting();
var inputFields = new List <DbField>();
// Filter the actual properties for input fields
inputFields = dbFields?
.Where(dbField => dbField.IsIdentity == false)
.Where(dbField =>
fields.FirstOrDefault(field => string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
.AsList();
// Identify the requests
var updateRequest = new UpdateRequest(tableName,
connection,
transaction,
where,
fields,
hints,
statementBuilder);
// Return the value
return(new UpdateExecutionContext <TEntity>
{
CommandText = CommandTextCache.GetUpdateText(updateRequest),
InputFields = inputFields,
ParametersSetterFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".Update"),
inputFields?.AsList(),
null,
dbSetting)
});
}
/// <summary>
/// Creates a SQL Statement for 'Update' operation.
/// </summary>
/// <param name="queryBuilder">The query builder to be used.</param>
/// <param name="tableName">The name of the target table.</param>
/// <param name="fields">The list of fields to be updated.</param>
/// <param name="where">The query expression.</param>
/// <param name="primaryField">The primary field from the database.</param>
/// <param name="identityField">The identity field from the database.</param>
/// <param name="hints">The table hints to be used.</param>
/// <returns>A sql statement for update operation.</returns>
public virtual string CreateUpdate(QueryBuilder queryBuilder,
string tableName,
IEnumerable <Field> fields,
QueryGroup where = null,
DbField primaryField = null,
DbField identityField = null,
string hints = null)
{
// Ensure with guards
GuardTableName(tableName);
GuardHints(hints);
GuardPrimary(primaryField);
GuardIdentity(identityField);
// Gets the updatable fields
var updatableFields = fields
.Where(f => !string.Equals(f.Name, primaryField?.Name, StringComparison.OrdinalIgnoreCase) &&
!string.Equals(f.Name, identityField?.Name, StringComparison.OrdinalIgnoreCase));
// Check if there are updatable fields
if (updatableFields?.Any() != true)
{
throw new EmptyException("The list of updatable fields cannot be null or empty.");
}
// Initialize the builder
var builder = queryBuilder ?? new QueryBuilder();
// Build the query
builder.Clear()
.Update()
.TableNameFrom(tableName, DbSetting)
.HintsFrom(hints)
.Set()
.FieldsAndParametersFrom(updatableFields, 0, DbSetting)
.WhereFrom(where, DbSetting)
.End();
// Return the query
return(builder.GetString());
}
/// <summary>
/// Creates a new instance of <see cref="QueryRequest"/> object.
/// </summary>
/// <param name="type">The target type.</param>
/// <param name="connection">The connection object.</param>
/// <param name="transaction">The transaction object.</param>
/// <param name="fields">The list of the target fields.</param>
/// <param name="where">The query expression.</param>
/// <param name="orderBy">The list of order fields.</param>
/// <param name="top">The filter for the rows.</param>
/// <param name="hints">The hints for the table.</param>
/// <param name="statementBuilder">The statement builder.</param>
public QueryRequest(Type type,
IDbConnection connection,
IDbTransaction transaction,
IEnumerable <Field> fields = null,
QueryGroup where = null,
IEnumerable <OrderField> orderBy = null,
int?top = null,
string hints = null,
IStatementBuilder statementBuilder = null)
: this(ClassMappedNameCache.Get(type),
connection,
transaction,
fields,
where,
orderBy,
top,
hints,
statementBuilder)
{
Type = type;
}
public void TestSqlStatementBuilderCreateCountWithWhereExpression()
{
// Setup
var statementBuilder = new SqlServerStatementBuilder();
var queryBuilder = new QueryBuilder();
var tableName = "Table";
var where = new QueryGroup(new QueryField("Id", 1));
// Act
var actual = statementBuilder.CreateCount(queryBuilder: queryBuilder,
tableName: tableName,
where : where);
var expected = $"" +
$"SELECT COUNT_BIG (1) AS [Counted] " +
$"FROM [Table] " +
$"WHERE ([Id] = @Id) ;";
// Assert
Assert.AreEqual(expected, actual);
}
public static bool IsValid(RhinoModelBase rModel, QueryGroup qGroup)
{
var result = false;
if (qGroup.IsAnd)
{
foreach (var qModel in qGroup)
{
result &= IsValid(rModel, qModel);
}
}
else
{
foreach (var qModel in qGroup)
{
result |= IsValid(rModel, qModel);
}
}
return(result);
}
public void TestPostgreSqlConnectionMaxAsyncViaQueryGroup()
{
// Setup
var tables = Database.CreateCompleteTables(10);
var queryFields = new[]
{
new QueryField("Id", Operation.GreaterThan, tables.First().Id),
new QueryField("Id", Operation.LessThan, tables.Last().Id)
};
var queryGroup = new QueryGroup(queryFields);
using (var connection = new NpgsqlConnection(Database.ConnectionString))
{
// Act
var result = connection.MaxAsync <CompleteTable>(e => e.ColumnInteger,
queryGroup).Result;
// Assert
Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id&& e.Id < tables.Last().Id).Max(e => e.ColumnInteger), Convert.ToInt32(result));
}
}
private void ParseSearchConfig(List<Macro> macros, List<QueryGroupCollection> queryGroupCollection, string filePath)
{
Regex regMacro = new Regex(@"^\$([^\t]+)\t([^\t]+)\t?", RegexOptions.IgnoreCase); // name + query
Regex regCommentGroupInfo = new Regex(@"^#\s([^\t]+)\t(.*)$", RegexOptions.IgnoreCase); // name + text
Regex regCommentCollection = new Regex(@"^#\s(?!Macros)[^\t]+$", RegexOptions.IgnoreCase); // whole lined
Regex regQuery = new Regex(@"^([^\t^#]+)\t([^\t]+)\t?", RegexOptions.IgnoreCase); // ID + query
QueryGroup queryGroup = new QueryGroup();
bool startNewGroup = false;
try
{
Match match;
using (StreamReader streamReader = new StreamReader(filePath))
{
string line;
while ((line = streamReader.ReadLine()) != null)
{
match = regMacro.Match(line);
if (match.Success)
{
macros.Add(new Macro(match.Groups[1].Value, match.Groups[2].Value));
continue;
}
match = regCommentCollection.Match(line);
if (match.Success)
{
if (queryGroupCollection.Count > 0)
if (queryGroup.queries.Count > 0 || queryGroup.info.Count > 0)
queryGroupCollection.Last().queryGroups.Add(queryGroup);
queryGroupCollection.Add(new QueryGroupCollection(match.Value));
startNewGroup = true;
queryGroup = new QueryGroup();
continue;
}
match = regCommentGroupInfo.Match(line);
if (match.Success)
{
if (startNewGroup)
{
if (queryGroup.queries.Count > 0 || queryGroup.info.Count > 0)
queryGroupCollection.Last().queryGroups.Add(queryGroup);
queryGroup = new QueryGroup();
startNewGroup = false;
}
queryGroup.info.Add(match.Value);
if (match.Groups[1].Value == "NAME" && queryGroup.ID == "")
queryGroup.ID = match.Groups[2].Value;
continue;
}
match = regQuery.Match(line);
if (match.Success)
{
queryGroup.queries.Add(new Query(match.Groups[1].Value, match.Groups[2].Value));
startNewGroup = true;
continue;
}
}
if (queryGroup.queries.Count > 0 || queryGroup.info.Count > 0)
queryGroupCollection.Last().queryGroups.Add(queryGroup);
}
}
catch (Exception e)
{
Console.WriteLine("\nParseSearchConfig() error: {0}!", e.Message);
System.Environment.Exit(1);
}
}
private void ParseStreamingConfig(List<QueryGroupCollection> queryGroupCollection, string filePath)
{
Regex regCommentGroupInfo = new Regex(@"^#\s([^\t]+)\t(.*)$", RegexOptions.IgnoreCase); // name + text
Regex regCommentCollection = new Regex(@"^#\s(?!Macros)[^\t]+$", RegexOptions.IgnoreCase); // whole lined
Regex regQuery = new Regex(@"^([^\t^#]+)\t([^\t]+)$", RegexOptions.IgnoreCase); // ID + query
QueryGroup queryGroup = new QueryGroup();
bool startNewGroup = false;
try
{
Match match;
using (StreamReader streamReader = new StreamReader(filePath))
{
string line;
while ((line = streamReader.ReadLine()) != null)
{
match = regCommentCollection.Match(line);
if (match.Success)
{
if (queryGroupCollection.Count > 0)
if (queryGroup.queries.Count > 0 || queryGroup.info.Count > 0)
queryGroupCollection.Last().queryGroups.Add(queryGroup);
queryGroupCollection.Add(new QueryGroupCollection(match.Value));
startNewGroup = true;
queryGroup = new QueryGroup();
continue;
}
match = regCommentGroupInfo.Match(line);
if (match.Success)
{
if (startNewGroup)
{
if (queryGroup.queries.Count > 0 || queryGroup.info.Count > 0)
queryGroupCollection.Last().queryGroups.Add(queryGroup);
queryGroup = new QueryGroup();
startNewGroup = false;
}
queryGroup.info.Add(match.Value);
if (match.Groups[1].Value == "NAME" && queryGroup.ID == "")
queryGroup.ID = match.Groups[2].Value;
if (match.Groups[1].Value == "ENTITY" && queryGroup.entityID == "")
queryGroup.entityID = match.Groups[2].Value;
continue;
}
match = regQuery.Match(line);
if (match.Success)
{
queryGroup.queriesIDs.Add(match.Groups[1].Value);
queryGroup.queries.Add(match.Groups[2].Value);
startNewGroup = true;
continue;
}
}
}
}
catch (Exception e)
{
StreamLogger.writeErrorToConsoleAndExit(e.Message,
"TwitterStreamingDacq.StreamConfigParser", "ParseStreamingConfig");
}
}
public QueryAttribute(string description, QueryGroup group)
{
_group = group;
_description = description;
}
