private DataStore(DataStoreType type, string collectionName, AbstractClient client = null)
: base(new KinveyQueryProvider(typeof(KinveyQueryable <T>), QueryParser.CreateDefault(), new KinveyQueryExecutor <T>()), typeof(T))
{
this.collectionName = collectionName;
if (client != null)
{
this.client = client;
}
else
{
this.client = Client.SharedClient;
}
if (type != DataStoreType.NETWORK)
{
this.cache = this.client.CacheManager.GetCache <T>(collectionName);
this.syncQueue = this.client.CacheManager.GetSyncQueue(collectionName);
}
this.storeType = type;
this.customRequestProperties = this.client.GetCustomRequestProperties();
this.networkFactory = new NetworkFactory(this.client);
this.DeltaSetFetchingEnabled = false;
this.AutoPagination = false;
}
private static IQueryProvider CreateQueryProvider(ITable table)
{
return(new DefaultQueryProvider(
typeof(PgSqlQueryable <>),
QueryParser.CreateDefault(),
new PgSqlQueryExecutor(table)));
}
public static ConditionCollection VisitStatementConditions <T>(Expression <Func <T, bool> > conditions, DatabaseMapper mapper, bool aliasTables)
{
// Build a new query
var queryParser = QueryParser.CreateDefault();
var queryExecutor = new StatementExecutor();
var query = new StatementQuery <T>(queryParser, queryExecutor);
// Create an expression to select from the query with the conditions so that we have a sequence for Re-Linq to parse
var expression = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { query.ElementType },
query.Expression,
conditions);
// Parse the expression with Re-Linq
var queryModel = queryParser.GetParsedQuery(expression);
// Get the conditions from the query model
var visitor = new StatementCreator(mapper, aliasTables);
visitor.SelectStatement = new SelectStatement();
queryModel.Accept(visitor);
return(visitor.SelectStatement.Conditions);
}
public void SetUp()
{
QuerySource = ExpressionHelper.CreateQueryable <Cook> ();
IndustrialSectorQuerySource = ExpressionHelper.CreateQueryable <Restaurant>();
DetailQuerySource = ExpressionHelper.CreateQueryable <Kitchen> ();
QueryParser = QueryParser.CreateDefault();
}
private static IQueryProvider CreateQueryProvider(DbConnection connection)
{
return(new DefaultQueryProvider(
typeof(PsqlQueryable <>),
QueryParser.CreateDefault(),
new PsqlQueryExecutor(connection)));
}
public static HiveQueryable <T> Queryable <T>(ThriftHive.Iface session)
{
var queryParser = QueryParser.CreateDefault();
var executer = new HiveQueryExecutor(session);
return(new HiveQueryable <T>(queryParser, executer, session));
}
/// <summary>
/// TODO
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public IQueryable <T> AsQueryable <T>(bool inferenceEnabled = false) where T : Resource
{
SparqlQueryExecutor executor = new SparqlQueryExecutor(this, inferenceEnabled);
QueryParser queryParser = QueryParser.CreateDefault();
return(new SparqlQueryable <T>(queryParser, executor));
}
public void SetUp()
{
QuerySource = ExpressionHelper.CreateQueryable <Cook> ();
IndustrialSectorQuerySource = ExpressionHelper.CreateQueryable <Restaurant>();
DetailQuerySource = ExpressionHelper.CreateQueryable <Kitchen> ();
QueryParser = QueryParser.CreateDefault();
QueryParserWithCustomizedPartialEvaluation = CreateQueryParserWithCustimizedPartialEvaluation();
}
/// <summary>
/// Creates a new entity collection
/// </summary>
/// <param name="context">The context that manages the entities</param>
/// <param name="parent">The parent entity that contains this collection</param>
/// <param name="propertyType">The property type that the collection maps to</param>
/// <param name="isInverse">True if the collection represents the inverse of <paramref name="propertyType"/></param>
public BrightstarEntityCollection(BrightstarEntityContext context, BrightstarEntityObject parent, string propertyType, bool isInverse = false) :
base(new EntityFrameworkCollectionQueryProvider(QueryParser.CreateDefault(), new EntityFrameworkQueryExecutor(context)))
{
_context = context;
_parent = parent;
_propertyTypeUri = propertyType;
_propertyType = _context.GetDataObject(new Uri(propertyType), false);
_isInverse = isInverse;
}
private static void CreateDefaultQueryParser()
{
Console.WriteLine("Creating QueryParser...");
var stopwatch = Stopwatch.StartNew();
QueryParser.CreateDefault();
stopwatch.Stop();
Console.WriteLine("Time taken: {0}ms, reference time: ~36ms", stopwatch.ElapsedMilliseconds);
}
private IQuery CreateNHQuery(ISession session, Expression queryExpression)
{
// 使用 QueryParser
// 将表达式转换为 QueryModel
QueryModel queryModel = QueryParser.CreateDefault().GetParsedQuery(queryExpression);
// 有了 QueryModel 之后
// 通过 QueryModelVisitorBase 的 Visitor 方法进行数据解析
return(HqlGeneratorQueryModelVisitor.GenerateHqlQuery(queryModel).CreateQuery(session));
}
public IQueryable <T> Create <T>(Uri uri)
{
var parser = QueryParser.CreateDefault();
var executor = new RestQueryExecutor(uri, _queryModelTranslator, _httpService);
var provider = new RestQueryProvider(parser, executor);
return(new RestQueryable <T>(provider));
}
public SpEntityQueryable(SpQueryArgs <TContext> args)
: this(QueryParser.CreateDefault(),
#if SP2013 || SP2016
new SpQueryExecutor <TEntity, TContext>(args)
#else
new SpAsyncQueryExecutor <TEntity, TContext>(args)
#endif
)
{
}
public void SetUp()
{
_mockRepository = new MockRepository();
_queryParserMock = _mockRepository.StrictMock <IQueryParser> ();
_executorMock = _mockRepository.StrictMock <IQueryExecutor> ();
_queryProvider = new TestQueryProvider(_queryParserMock, _executorMock);
_queryableWithDefaultParser = new TestQueryable <Cook> (QueryParser.CreateDefault(), _executorMock);
_fakeQueryModel = ExpressionHelper.CreateQueryModel <Cook> ();
}
public static RethinkQueryable <T> AsQueryable <T>(this Table term, IConnection conn)
{
var executor = new RethinkQueryExecutor(term, conn);
return(new RethinkQueryable <T>(
new DefaultQueryProvider(
typeof(RethinkQueryable <>),
QueryParser.CreateDefault(),
executor)
));
}
public void Test()
{
var queryParser = QueryParser.CreateDefault();
var context = new WssQuery <IWssQueryableListItem>(queryParser, new WssQueryExecutor());
var query = context.Where(item => item.Id > 0 && string.IsNullOrWhiteSpace(item.Title));
var camlVersion = query.ToCamlTree();
var list = query.ToList();
}
// This constructor is called by users, create a new IQueryExecutor.
internal ExcelQueryable(ExcelQueryArgs args, ILogManagerFactory logManagerFactory)
: base(QueryParser.CreateDefault(), CreateExecutor(args, logManagerFactory))
{
foreach (var property in typeof(T).GetProperties())
{
ExcelColumnAttribute att = (ExcelColumnAttribute)Attribute.GetCustomAttribute(property, typeof(ExcelColumnAttribute));
if (att != null && !args.ColumnMappings.ContainsKey(property.Name))
{
args.ColumnMappings.Add(property.Name, att.ColumnName);
}
}
}
static void Main(string[] args)
{
var queryParser = QueryParser.CreateDefault();
var items = new SampleQueryable <SampleDataSourceItem>(queryParser, new SampleQueryExecutor());
var results = from i in items select i;
var list = results.ToList();
if (list.Count == 10)
{
}
}
protected RethinkQueryable <T> GetQueryable <T>(string table, ReqlAst expected)
{
var executor = new TestRethinkQueryExecutor(RethinkDB.R.Table(table), Connection, reql =>
{
QueriesAreTheSame(expected, reql);
});
return(new RethinkQueryable <T>(
new DefaultQueryProvider(
typeof(RethinkQueryable <>),
QueryParser.CreateDefault(),
executor)
));
}
// This constructor is called by users, create a new IQueryExecutor.
internal ExcelQueryable(ExcelQueryArgs args, ILogManagerFactory logManagerFactory)
: base(QueryParser.CreateDefault(), CreateExecutor(args, logManagerFactory))
{
foreach (var property in typeof(T).GetProperties())
{
ExcelColumnAttribute att = (ExcelColumnAttribute)Attribute.GetCustomAttribute(property, typeof(ExcelColumnAttribute));
if (att != null && !args.ColumnMappings.ContainsKey(property.Name))
{
var columnNames = ExcelUtilities.GetColumnNames(args);
args.ColumnMappings.Add(property.Name, !att.IsForced ?
att.ColumnName :
columnNames.ToList().Find(x => att.HasSimilarColumn(x)) ?? att.ColumnName);
}
}
}
public static SqlServerQueryable <T> AsLinqQueryable <T>(this IDBContext <T> context) where T : BaseEntity <T>, new()
{
ISQLContext sqlContext = new SQLContext(context.Session);
var tblName = "";
var proxy = EntitiesProxyHelper.GetProxyInfo <T>();
if (proxy.IsCompositeQuery)
{
tblName = string.Format(" ({0}) ", proxy.CompositeSql);
}
else
{
tblName = proxy.TableName;
}
return(new SqlServerQueryable <T>(QueryParser.CreateDefault(), new SqlServerQueryExecutor(sqlContext, tblName)));
}
public static void AddFilter <TSource>(
IServiceProvider Locator,
IDatabaseQuery query,
ISpecification <TSource> filter,
StringBuilder sb)
{
var cf = Locator.Resolve <IPostgresConverterFactory>();
var ep = Locator.Resolve <IExtensibilityProvider>();
var qp =
new MainQueryParts(
Locator,
cf,
ep.ResolvePlugins <IQuerySimplification>(),
ep.ResolvePlugins <IExpressionMatcher>(),
ep.ResolvePlugins <IMemberMatcher>(),
new IProjectionMatcher[0]);
var linq = new Queryable <TSource>(new QueryExecutor(query, Locator, cf, ep)).Filter(filter);
var parser = QueryParser.CreateDefault();
var model = parser.GetParsedQuery(linq.Expression);
if (model.BodyClauses.Count > 0)
{
sb.AppendLine("WHERE");
for (int i = 0; i < model.BodyClauses.Count; i++)
{
var wc = model.BodyClauses[i] as WhereClause;
if (wc == null)
{
continue;
}
sb.Append(" ");
if (i > 0)
{
sb.Append("AND ");
}
sb.Append(qp.GetSqlExpression(wc.Predicate));
}
}
}
public IQueryable <T> CreateQueryable <T>(ISessionProvider provider)
{
return(new OracleQueryable <T>(QueryParser.CreateDefault(), new OracleQueryExecutor(provider)));
}
// This constructor is called by our users, create a new IQueryExecutor.
public CouchDbQueryable(string url, string databaseName)
: base(QueryParser.CreateDefault(), CreateExecutor(url, databaseName))
{
}
public SqlQueryable()
: this(QueryParser.CreateDefault(), new SqlQueryableExecutor())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataQueryable{T}"/> class.
/// </summary>
/// <param name="odata">The <see cref="ODataBase"/>.</param>
/// <param name="queryArgs">The <see cref="ODataArgs"/>.</param>
/// <param name="executor">The <see cref="IQueryExecutor"/>.</param>
public ODataQueryable(ODataBase odata, ODataArgs queryArgs, ref IQueryExecutor executor)
: base(QueryParser.CreateDefault(), CreateExecutor(odata, queryArgs, ref executor))
{
QueryExecutor = (ODataQueryExecutor)executor;
}
public Queryable(IQueryExecutor executor)
: base(QueryParser.CreateDefault(), executor)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Queryable{T}"/> class with a specific <see cref="ITypedQueryExecutor{T}"/>
/// and the default <see cref="IQueryParser"/>.
/// This constructor should normally not be used.
/// </summary>
/// <param name="executor">The <see cref="ITypedQueryExecutor{T}"/> used to execute the query.</param>
public Queryable(ITypedQueryExecutor <T> executor)
: base(QueryParser.CreateDefault(), executor)
{
}
public static IQueryProvider CreateQueryProvider <T>(ProjectionApi session)
{
return(new DefaultQueryProvider(typeof(ProjectionQueryable <>), QueryParser.CreateDefault(), CreateExecutor(session)));
}
public DataTable Analyze(
IEnumerable <string> dimensions,
IEnumerable <string> facts,
IEnumerable <KeyValuePair <string, bool> > order,
ISpecification <TSource> filter,
int?limit,
int?offset)
{
var usedDimensions = new List <string>();
var usedFacts = new List <string>();
var customOrder = new List <KeyValuePair <string, bool> >();
if (dimensions != null)
{
usedDimensions.AddRange(dimensions);
}
if (facts != null)
{
usedFacts.AddRange(facts);
}
if (order != null)
{
foreach (var o in order)
{
if (o.Key != null)
{
customOrder.Add(new KeyValuePair <string, bool>(o.Key, o.Value));
}
}
}
ValidateInput(usedDimensions, usedFacts, customOrder.Select(it => it.Key));
var sb = new StringBuilder();
var alias = filter != null?filter.IsSatisfied.Parameters.First().Name : "it";
if (offset != null)
{
sb.Append("SELECT ");
sb.Append(string.Join(", ", usedDimensions.UnionAll(usedFacts).Select(it => "\"" + it + "\"")));
sb.AppendLine(" FROM (");
}
if (limit != null || offset != null)
{
sb.Append("SELECT /*+ FIRST_ROWS(n) */ ");
sb.Append(string.Join(", ", usedDimensions.UnionAll(usedFacts).Select(it => "\"" + it + "\"")));
if (offset != null)
{
sb.Append(", RowNum rn$");
}
sb.AppendLine(" FROM (");
}
sb.Append("SELECT ");
foreach (var d in usedDimensions)
{
sb.AppendFormat("{0} AS \"{1}\", ", CubeDimensions[d](alias), d);
}
foreach (var f in usedFacts)
{
sb.AppendFormat("{0} AS \"{1}\", ", CubeFacts[f](alias), f);
}
sb.Length -= 2;
sb.AppendLine();
sb.AppendFormat("FROM {0} \"{1}\"", Source, alias);
sb.AppendLine();
var command = DatabaseQuery.NewCommand();
if (filter != null)
{
var cf = Locator.Resolve <IOracleConverterFactory>();
var ep = Locator.Resolve <IExtensibilityProvider>();
var qp =
new MainQueryParts(
Locator,
cf,
ep.ResolvePlugins <IQuerySimplification>(),
ep.ResolvePlugins <IExpressionMatcher>(),
ep.ResolvePlugins <IMemberMatcher>(),
new IProjectionMatcher[0]);
var linq = new Queryable <TSource>(new QueryExecutor(DatabaseQuery, Locator, cf, ep)).Filter(filter);
var parser = QueryParser.CreateDefault();
var model = parser.GetParsedQuery(linq.Expression);
if (model.BodyClauses.Count > 0)
{
sb.AppendLine("WHERE");
for (int i = 0; i < model.BodyClauses.Count; i++)
{
var wc = model.BodyClauses[i] as WhereClause;
sb.Append(" ");
if (i > 0)
{
sb.Append("AND ");
}
sb.Append(qp.GetSqlExpression(wc.Predicate));
}
}
foreach (var p in qp.Parameters.Parameters)
{
command.Parameters.Add(p);
}
}
sb.AppendLine();
if (usedDimensions.Count > 0)
{
sb.Append("GROUP BY ");
sb.AppendLine(string.Join(", ", usedDimensions.Select(it => CubeDimensions[it](alias))));
}
if (customOrder.Count > 0)
{
sb.Append("ORDER BY ");
sb.AppendLine(string.Join(", ", customOrder.Select(it => "\"{0}\" {1}".With(it.Key, it.Value ? string.Empty : "DESC"))));
}
if (limit != null || offset != null)
{
sb.AppendLine(") sq$");
if (limit != null)
{
sb.Append("WHERE RowNum <= ");
sb.Append(limit.Value + (offset != null ? offset.Value : 0));
}
}
if (offset != null)
{
sb.AppendLine(") sq$");
sb.Append("WHERE sq$.rn$ > ");
sb.Append(offset.Value);
}
command.CommandText = sb.ToString();
return(DatabaseQuery.Fill(command));
}
