public override ITable Evaluate(IQueryContext context)
{
var leftResult = Left.Evaluate(context);
var rightResult = Right.Evaluate(context);
return leftResult.Union(rightResult);
}
public ChildQueryContext(IQueryContext parentContext)
{
if (parentContext == null)
throw new ArgumentNullException("parentContext");
this.parentContext = parentContext;
}
public override ITable Evaluate(IQueryContext context)
{
// Solve the left branch result
ITable leftResult = Left.Evaluate(context);
// Solve the right branch result
ITable rightResult = Right.Evaluate(context);
// If the rightExpression is a simple variable then we have the option
// of optimizing this join by putting the smallest table on the LHS.
ObjectName rhsVar = rightExpression.AsVariable();
ObjectName lhsVar = leftVar;
Operator op = joinOp;
if (rhsVar != null) {
// We should arrange the expression so the right table is the smallest
// of the sides.
// If the left result is less than the right result
if (leftResult.RowCount < rightResult.RowCount) {
// Reverse the join
rightExpression = Expression.Variable(lhsVar);
lhsVar = rhsVar;
op = op.Reverse();
// Reverse the tables.
ITable t = rightResult;
rightResult = leftResult;
leftResult = t;
}
}
// The join operation.
return leftResult.SimpleJoin(context, rightResult, lhsVar, op, rightExpression);
}
protected override void Dispose(bool disposing)
{
parentContext = null;
executeContext = null;
base.Dispose(disposing);
}
/// <inheritdoc/>
public virtual ITable Evaluate(IQueryContext context)
{
// MILD HACK: Cast the context to a DatabaseQueryContext
//DatabaseQueryContext dbContext = (DatabaseQueryContext)context;
//return dbContext.Database.SingleRowTable;
throw new NotImplementedException();
}
public override ITable Evaluate(IQueryContext context)
{
// Evaluate the child
ITable t = Child.Evaluate(context);
var binary = (BinaryExpression) expression;
// Perform the pattern search expression on the table.
ObjectName lhsVar = binary.Left.AsVariable();
if (lhsVar != null) {
// LHS is a simple variable so do a simple select
Operator op = binary.Operator;
return t.SimpleSelect(context, lhsVar, op, binary.Right);
}
// LHS must be a constant so we can just evaluate the expression
// and see if we get true, false, null, etc.
DataObject v = expression.Evaluate(context);
// If it evaluates to NULL or FALSE then return an empty set
if (v.IsNull || v.Value.Equals(false))
return t.EmptySelect();
return t;
}
public override ITable Evaluate(IQueryContext context)
{
// Solve the left branch result
var leftResult = Left.Evaluate(context);
// Solve the Join (natural)
return leftResult.NaturalJoin(Right.Evaluate(context));
}
private void updateVerseTable(IQueryContext context, SqliteTransaction transaction)
{
var sql = SqlBuilder.Update("Verses")
.Set(DbVerse.BookField + " = @Book",
DbVerse.BeginChapterField + " = @BeginChapter",
DbVerse.EndChapterField + " = @EndChapter",
DbVerse.BeginVerseField + " = @BeginVerse",
DbVerse.EndVerseField + " = @EndVerse",
DbVerse.BodyField + " = @Body",
DbVerse.TitleField + " = @Title",
DbVerse.DateField + " = @Date",
DbVerse.TranslationField + " = @Translation")
.Where(DbVerse.VerseIdField + " = @VerseId");
var sqlParams = new
{
Book = _verse.Reference.Book.Id,
BeginChapter = _verse.Reference.From.Chapter,
EndChapter = _verse.Reference.To.Chapter,
BeginVerse = _verse.Reference.From.Verse,
EndVerse = _verse.Reference.To.Verse,
Body = _verse.Body,
Title = _verse.Title,
Date = _verse.Date,
Translation = _verse.Translation.ToDatabaseEntity().Id,
VerseId = _verse.VerseId
};
context.Connection.Execute(sql, transaction, sqlParams);
}
/// <inheritdoc/>
public override ITable Evaluate(IQueryContext context)
{
var t = Child.Evaluate(context);
var exp = Expression;
// Assert that all variables in the expression are identical.
var columnNames = exp.DiscoverReferences();
ObjectName columnName = null;
foreach (var cv in columnNames) {
if (columnName != null && !cv.Equals(columnName))
throw new InvalidOperationException("Range plan does not contain common column.");
columnName = cv;
}
// Find the variable field in the table.
var col = t.IndexOfColumn(columnName);
if (col == -1)
throw new InvalidOperationException("Could not find column reference in table: " + columnName);
var field = t.TableInfo[col];
// Calculate the range
var range = new IndexRangeSet();
var calculator = new RangeSetCalculator(context, field, range);
range = calculator.Calculate(exp);
// Select the range from the table
var ranges = range.ToArray();
return t.SelectRange(columnName, ranges);
}
public static void CreateViews(IQueryContext context)
{
// This view shows the grants that the user has (no join, only priv_bit).
context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserSimpleGrant AS " +
" SELECT \"priv_bit\", \"object\", \"name\", \"user\", " +
" \"grant_option\", \"granter\" " +
" FROM " + SystemSchema.UserGrantsTableName +
" WHERE ( user = user() OR user = '******' )");
// This view shows the grants that the user is allowed to see
context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserGrant AS " +
" SELECT \"description\", \"object\", \"name\", \"user\", " +
" \"grant_option\", \"granter\" " +
" FROM " + SystemSchema.UserGrantsTableName + ", " + SystemSchema.PrivilegesTableName +
" WHERE ( user = user() OR user = '******' )" +
" AND " + SystemSchema.UserGrantsTableName + ".priv_bit = " +
SystemSchema.PrivilegesTableName + ".priv_bit");
// A view that represents the list of schema this user is allowed to view
// the contents of.
context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserSchemaInfo AS " +
" SELECT * FROM " + SystemSchema.SchemaInfoTableName +
" WHERE \"name\" IN ( " +
" SELECT \"name\" " +
" FROM INFORMATION_SCHEMA.ThisUserGrant " +
" WHERE \"object\" = " + ((int)DbObjectType.Schema) +
" AND \"description\" = '" + Privileges.List + "' )");
// A view that exposes the table_columns table but only for the tables
// this user has read access to.
context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserTableColumns AS " +
" SELECT * FROM " + SystemSchema.TableColumnsTableName +
" WHERE \"schema\" IN ( " +
" SELECT \"name\" FROM INFORMATION_SCHEMA.ThisUserSchemaInfo )");
// A view that exposes the 'table_info' table but only for the tables
// this user has read access to.
context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserTableInfo AS " +
" SELECT * FROM " + SystemSchema.TableInfoTableName +
" WHERE \"schema\" IN ( " +
" SELECT \"name\" FROM INFORMATION_SCHEMA.ThisUserSchemaInfo )");
context.ExecuteQuery(" CREATE VIEW " + Tables + " AS " +
" SELECT NULL AS \"TABLE_CATALOG\", \n" +
" \"schema\" AS \"TABLE_SCHEMA\", \n" +
" \"name\" AS \"TABLE_NAME\", \n" +
" \"type\" AS \"TABLE_TYPE\", \n" +
" \"other\" AS \"REMARKS\", \n" +
" NULL AS \"TYPE_CATALOG\", \n" +
" NULL AS \"TYPE_SCHEMA\", \n" +
" NULL AS \"TYPE_NAME\", \n" +
" NULL AS \"SELF_REFERENCING_COL_NAME\", \n" +
" NULL AS \"REF_GENERATION\" \n" +
" FROM INFORMATION_SCHEMA.ThisUserTableInfo \n");
context.ExecuteQuery(" CREATE VIEW " + Schemata + " AS " +
" SELECT \"name\" AS \"TABLE_SCHEMA\", \n" +
" NULL AS \"TABLE_CATALOG\" \n" +
" FROM INFORMATION_SCHEMA.ThisUserSchemaInfo\n");
}
protected override SqlPreparedStatement PrepareStatement(IExpressionPreparer preparer, IQueryContext context)
{
var tableName = context.ResolveTableName(TableName);
if (!context.TableExists(tableName))
throw new ObjectNotFoundException(tableName);
var queryExpression = new SqlQueryExpression(new[]{SelectColumn.Glob("*") });
queryExpression.FromClause.AddTable(tableName.FullName);
queryExpression.WhereExpression = WherExpression;
var queryFrom = QueryExpressionFrom.Create(context, queryExpression);
var queryPlan = context.DatabaseContext().QueryPlanner().PlanQuery(context, queryExpression, null);
var columns = new List<SqlAssignExpression>();
foreach (var assignment in Assignments) {
var columnName = ObjectName.Parse(assignment.ColumnName);
var refName = queryFrom.ResolveReference(columnName);
var expression = assignment.Expression.Prepare(queryFrom.ExpressionPreparer);
var assign = SqlExpression.Assign(SqlExpression.Reference(refName), expression);
columns.Add(assign);
}
return new Prepared(tableName, queryPlan, columns.ToArray(), Limit);
}
private void AddTestData(IQueryContext context)
{
var table = context.GetMutableTable(ObjectName.Parse("APP.test_table"));
var row = table.NewRow();
row.SetValue("id", DataObject.Integer(0));
row.SetValue("first_name", DataObject.String("John"));
row.SetValue("last_name", DataObject.String("Doe"));
row.SetValue("birth_date", DataObject.Date(new SqlDateTime(1977, 01, 01)));
row.SetValue("active", DataObject.Boolean(false));
table.AddRow(row);
row = table.NewRow();
row.SetValue("id", DataObject.Integer(1));
row.SetValue("first_name", DataObject.String("Jane"));
row.SetValue("last_name", DataObject.String("Doe"));
row.SetValue("birth_date", DataObject.Date(new SqlDateTime(1978, 11, 01)));
row.SetValue("active", DataObject.Boolean(true));
table.AddRow(row);
row = table.NewRow();
row.SetValue("id", DataObject.Integer(2));
row.SetValue("first_name", DataObject.String("Roger"));
row.SetValue("last_name", DataObject.String("Rabbit"));
row.SetValue("birth_date", DataObject.Date(new SqlDateTime(1985, 05, 05)));
row.SetValue("active", DataObject.Boolean(true));
table.AddRow(row);
}
public override ITable Evaluate(IQueryContext context)
{
ITable t = Child.Evaluate(context);
// NOTE: currently this uses exhaustive select but should exploit
// function indexes when they are available.
return t.ExhaustiveSelect(context, expression);
}
internal override bool MatchesInvoke(Invoke invoke, IQueryContext queryContext)
{
if (invoke == null)
return false;
bool ignoreCase = true;
if (queryContext != null)
ignoreCase = queryContext.IgnoreIdentifiersCase();
if (!RoutineName.Equals(invoke.RoutineName, ignoreCase))
return false;
var inputParams = Parameters.Where(parameter => parameter.IsInput).ToList();
if (invoke.Arguments.Length != inputParams.Count)
return false;
for (int i = 0; i < invoke.Arguments.Length; i++) {
// TODO: support variable evaluation here? or evaluate parameters before reaching here?
if (!invoke.Arguments[i].IsConstant())
return false;
var argType = invoke.Arguments[i].ReturnType(queryContext, null);
var paramType = Parameters[i].Type;
// TODO: verify if this is assignable (castable) ...
if (!paramType.IsComparable(argType))
return false;
}
return true;
}
public GrantManager(IUserSession session)
{
Session = session;
context = new SessionQueryContext(session);
privCache = new MemoryCache(16, 256, 10);
}
public ReturnTypeVisitor(IQueryContext queryContext, IVariableResolver variableResolver)
{
this.queryContext = queryContext;
this.variableResolver = variableResolver;
dataType = PrimitiveTypes.Null();
}
public ITable Evaluate(IQueryContext context)
{
IQueryPlanNode node = CreateChildNode(context);
var t = node.Evaluate(context);
return AliasName != null ? new ReferenceTable(t, AliasName) : t;
}
protected override SqlPreparedStatement PrepareStatement(IExpressionPreparer preparer, IQueryContext context)
{
if (String.IsNullOrEmpty(TableName))
throw new StatementPrepareException("The table name is required.");
var tableName = context.ResolveTableName(TableName);
return new Prepared(tableName, Action);
}
public override ITable Evaluate(IQueryContext context)
{
var leftResult = Left.Evaluate(context);
var rightResult = Right.Evaluate(context);
// Form the composite table
return leftResult.Composite(rightResult, CompositeFunction, All);
}
public override ITable Evaluate(IQueryContext context)
{
// Solve the child branch result
var table = Child.Evaluate(context);
// The select operation.
return table.SimpleSelect(context, ColumnName, OperatorType, Expression);
}
public static void CreateViews(IQueryContext context)
{
context.ExecuteCreateView("INFORMATION_SCHEMA.ThisUserSimpleGrant",
" SELECT \"priv_bit\", \"object\", \"param\", \"grantee\", " +
" \"grant_option\", \"granter\" " +
" FROM " + SystemSchema.UserGrantsTableName +
" WHERE ( grantee = user() OR grantee = '@PUBLIC' )");
}
public CursorManager(IQueryContext context)
{
if (context == null)
throw new ArgumentNullException("context");
Context = context;
cursors = new List<Cursor>();
}
/// <summary>
/// Constructs a new user with the given name.
/// </summary>
/// <param name="name"></param>
internal User(IQueryContext context, string name)
{
if (String.IsNullOrEmpty(name))
throw new ArgumentNullException("name");
Context = context;
Name = name;
}
public IQueryPlanNode PlanQuery(IQueryContext context, SqlQueryExpression queryExpression, IEnumerable<SortColumn> sortColumns)
{
var queryFrom = QueryExpressionFrom.Create(context, queryExpression);
var orderBy = new List<SortColumn>();
if (sortColumns != null)
orderBy.AddRange(sortColumns);
return PlanQuery(context, queryExpression, queryFrom, orderBy);
}
public override ITable Evaluate(IQueryContext context)
{
// Solve the left branch result
ITable leftResult = Left.Evaluate(context);
// Solve the right branch result
ITable rightResult = Right.Evaluate(context);
return leftResult.Union(rightResult);
}
public override ITable Evaluate(IQueryContext context)
{
// Solve the left branch result
var leftResult = Left.Evaluate(context);
// Solve the right branch result
var rightResult = Right.Evaluate(context);
return leftResult.Join(context, rightResult, LeftColumnName, Operator, RightExpression);
}
public override ITable Evaluate(IQueryContext context)
{
// Solve the left branch result
var leftResult = Left.Evaluate(context);
// Solve the right branch result
var rightResult = Right.Evaluate(context);
return leftResult.EquiJoin(context, rightResult, LeftColumns, RightColumns);
}
public FunctionTable(ITable table, SqlExpression[] functionList, string[] columnNames, IQueryContext queryContext)
: base(queryContext.DatabaseContext())
{
// Make sure we are synchronized over the class.
lock (typeof(FunctionTable)) {
uniqueId = uniqueKeySeq;
++uniqueKeySeq;
}
uniqueId = (uniqueId & 0x0FFFFFFF) | 0x010000000;
context = queryContext;
ReferenceTable = table;
varResolver = table.GetVariableResolver();
varResolver = varResolver.ForRow(0);
// Create a DataTableInfo object for this function table.
funTableInfo = new TableInfo(FunctionTableName);
expList = new SqlExpression[functionList.Length];
expInfo = new byte[functionList.Length];
// Create a new DataColumnInfo for each expression, and work out if the
// expression is simple or not.
for (int i = 0; i < functionList.Length; ++i) {
var expr = functionList[i];
// Examine the expression and determine if it is simple or not
if (expr.IsConstant() && !expr.HasAggregate(context)) {
// If expression is a constant, solve it
var result = expr.Evaluate(context, null);
if (result.ExpressionType != SqlExpressionType.Constant)
throw new InvalidOperationException();
expr = result;
expList[i] = expr;
expInfo[i] = 1;
} else {
// Otherwise must be dynamic
expList[i] = expr;
expInfo[i] = 0;
}
// Make the column info
funTableInfo.AddColumn(columnNames[i], expr.ReturnType(context, varResolver));
}
// Make sure the table info isn't changed from this point on.
funTableInfo = funTableInfo.AsReadOnly();
// routine tables are the size of the referring table.
rowCount = table.RowCount;
// Set schemes to 'blind search'.
SetupIndexes(DefaultIndexTypes.BlindSearch);
}
public FunctionQueryContext(IQueryContext parentContext, ExecuteContext executeContext)
{
if (parentContext == null)
throw new ArgumentNullException("parentContext");
if (executeContext == null)
throw new ArgumentNullException("executeContext");
this.parentContext = parentContext;
this.executeContext = executeContext;
}
/// <summary>
/// Checks if a function matched against the given request represents
/// an aggregate function.
/// </summary>
/// <param name="resolver">The routine resolver.</param>
/// <param name="request">The invocation request used to resolve the function.</param>
/// <param name="context">The parent query context.</param>
/// <returns>
/// Returns <c>true</c> if a routine was resolved for the given request,
/// this is a <see cref="IFunction"/> and the <see cref="FunctionType"/> is
/// <see cref="FunctionType.Aggregate"/>, otherwise <c>false</c>.
/// </returns>
public static bool IsAggregateFunction(this IRoutineResolver resolver, Invoke request, IQueryContext context)
{
var routine = resolver.ResolveRoutine(request, context);
var function = routine as IFunction;
if (function == null)
return false;
return function.FunctionType == FunctionType.Aggregate;
}
private IEnumerable <DynamicPropertyResult> IsSalientPropertyCalculator(IQueryContext context, Name identity)
{
foreach (var c in context.Constraints)
{
identity = identity.MakeGround(c);
if (identity.IsGrounded)
{
if (m_activeIdentities.ContainsKey(identity))
{
var id = m_activeIdentities[identity];
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(true), id.Salience), c));
}
else
{
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(false)), c));
}
}
}
}
private static LucQuery Compile(SnQuery query, IQueryContext context)
{
var analyzer = SearchManager.Instance.GetAnalyzer();
var visitor = new SnQueryToLucQueryVisitor(analyzer, context);
visitor.Visit(query.QueryTree);
var result = LucQuery.Create(visitor.Result, SearchManager.Instance);
result.Skip = query.Skip;
result.Top = query.Top;
result.SortFields = query.Sort?.Select(s => CreateSortField(s.FieldName, s.Reverse)).ToArray() ?? new SortField[0];
result.EnableAutofilters = query.EnableAutofilters;
result.EnableLifespanFilter = query.EnableLifespanFilter;
result.QueryExecutionMode = query.QueryExecutionMode;
result.CountOnly = query.CountOnly;
result.CountAllPages = query.CountAllPages;
return(result);
}
//This is where the main body of the MCTS Search must be implemented
private IEnumerable <DynamicPropertyResult> MCTSSearch(IQueryContext context, Name actionVar, Name targetVar)
{
//How to clone the KB with our JSON serializer
var jsonSerializer = new JSONSerializer();
var memStream = new MemoryStream();
var json = jsonSerializer.SerializeToJson(this.m_kb);
var kbCloned = jsonSerializer.DeserializeFromJson <KB>(json);
//This is just an example of how to always return the action "Pick" with target "Wood1"
var actionSub = new Substitution(actionVar, new ComplexValue(Name.BuildName("Pick")));
var targetSub = new Substitution(targetVar, new ComplexValue(Name.BuildName("Wood1")));
foreach (var subSet in context.Constraints)
{
subSet.AddSubstitution(actionSub);
subSet.AddSubstitution(targetSub);
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(true), 1.0f), subSet));
}
}
public static bool ObjectExists(this IQueryContext context, DbObjectType objectType, ObjectName objectName)
{
// Special types for these database objects that can be
// declared in a limited context
if (objectType == DbObjectType.Cursor &&
context.CursorExists(objectName.Name))
{
return(true);
}
if (objectType == DbObjectType.Variable &&
context.VariableExists(objectName.Name))
{
return(true);
}
// We haven't found it neither in this context nor in the parent:
// fallback to the transaction scope
return(context.Session().ObjectExists(objectType, objectName));
}
public static void GrantTo(this IQueryContext context, string groupOrUserName, DbObjectType objectType, ObjectName objectName, Privileges privileges, bool withOption = false)
{
if (context.ForSystemUser().UserManager().UserGroupExists(groupOrUserName))
{
if (withOption)
{
throw new SecurityException("User groups cannot be granted with grant option.");
}
context.GrantToGroupOn(objectType, objectName, groupOrUserName, privileges);
}
else if (context.ForSystemUser().UserManager().UserExists(groupOrUserName))
{
context.GrantToUserOn(objectType, objectName, groupOrUserName, privileges, withOption);
}
else
{
throw new SecurityException(String.Format("User or group '{0}' was not found.", groupOrUserName));
}
}
public static User GetUser(this IQueryContext context, string userName)
{
if (context.UserName().Equals(userName, StringComparison.OrdinalIgnoreCase))
{
return(new User(context, userName));
}
if (!context.UserCanAccessUsers())
{
throw new MissingPrivilegesException(context.UserName(), new ObjectName(userName), Privileges.Select,
String.Format("The user '{0}' has not enough rights to access other users information.", context.UserName()));
}
if (!context.ForSystemUser().UserManager().UserExists(userName))
{
return(null);
}
return(new User(context, userName));
}
private async Task <Dictionary <SubscriptionInfo, StockQueryResult> > GetSubscriptionNeedRefreshing(IList <SubscriptionInfo> subscriptions)
{
var results = new Dictionary <SubscriptionInfo, StockQueryResult>();
foreach (var info in subscriptions)
{
IQueryContext queryContext = info.Query.CreateContext(_contextFactory);
StockQueryResult queryResult = await queryContext.GetCachedQueryResult(info.Query.SymbolId);
bool queryNeedsRefresh = queryResult == null || info.Query.FunctionType.IsExpired(queryResult.Data.LastUpdated, DateTime.UtcNow);
if (queryNeedsRefresh)
{
results.Add(info, queryResult);
}
}
return(results);
}
public static Activity BeginExecute(IQueryContext context)
{
var payload = new
{
schema = context.Schema,
request = context.Request,
query = context.Document
};
if (_src.IsEnabled(DiagnosticNames.Query, payload))
{
var activity = new Activity(DiagnosticNames.Query);
_src.StartActivity(activity, payload);
return(activity);
}
return(null);
}
public static void EndValidation(
Activity activity,
IQueryContext context)
{
if (activity != null)
{
var payload = new
{
schema = context.Schema,
request = context.Request,
query = context.Document,
result = context.ValidationResult
};
if (_src.IsEnabled(DiagnosticNames.Validation, payload))
{
_src.StopActivity(activity, payload);
}
}
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
bool?b1 = ob1.ToBoolean();
bool?b2 = ob2.ToBoolean();
// If either ob1 or ob2 are null
if (!b1.HasValue)
{
return(b2.HasValue && b2.Value.Equals(true) ? DataObject.BooleanTrue : DataObject.BooleanNull);
}
if (!b2.HasValue)
{
return(b1.Value.Equals(true) ? DataObject.BooleanTrue : DataObject.BooleanNull);
}
// If both true.
return(DataObject.Boolean(b1.Equals(true) || b2.Equals(true)));
}
private IEnumerable <DynamicPropertyResult> ValidDialogPropertyCalculator(IQueryContext context, Name currentState, Name nextState, Name meaning, Name style)
{
if (!context.Perspective.Match(Name.SELF_SYMBOL))
{
yield break;
}
var key = Name.BuildName(string.Format(IATConsts.DIALOG_ACTION_KEY + "({0},{1},{2},{3})",
currentState, nextState, meaning, style));
foreach (var c in context.Constraints)
{
var dialogues = m_dialogues.GetAllDialogsForKey(key, c);
foreach (var d in dialogues)
{
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(true)), d.Item2));
}
}
}
static void GetParameters(DataConnection dataConnection, IQueryContext query, PreparedQuery pq)
{
var parameters = query.GetParameters();
if (parameters.Length == 0 && pq.SqlParameters.Count == 0)
{
return;
}
var ordered = dataConnection.DataProvider.SqlProviderFlags.IsParameterOrderDependent;
var c = ordered ? pq.SqlParameters.Count : parameters.Length;
var parms = new List <IDbDataParameter>(c);
if (ordered)
{
for (var i = 0; i < pq.SqlParameters.Count; i++)
{
var sqlp = pq.SqlParameters[i];
if (sqlp.IsQueryParameter)
{
var parm = parameters.Length > i && object.ReferenceEquals(parameters[i], sqlp) ?
parameters[i] :
parameters.First(p => object.ReferenceEquals(p, sqlp));
AddParameter(dataConnection, parms, parm.Name, parm);
}
}
}
else
{
foreach (var parm in parameters)
{
if (parm.IsQueryParameter && pq.SqlParameters.Contains(parm))
{
AddParameter(dataConnection, parms, parm.Name, parm);
}
}
}
pq.Parameters = parms.ToArray();
}
void GetParameters(IQueryContext query, PreparedQuery pq)
{
var parameters = query.GetParameters();
if (parameters.Length == 0 && pq.SqlParameters.Count == 0)
{
return;
}
var x = DataProvider.Convert("x", ConvertType.NameToQueryParameter).ToString();
var y = DataProvider.Convert("y", ConvertType.NameToQueryParameter).ToString();
var parms = new List <IDbDataParameter>(x == y ? pq.SqlParameters.Count : parameters.Length);
if (x == y)
{
for (var i = 0; i < pq.SqlParameters.Count; i++)
{
var sqlp = pq.SqlParameters[i];
if (sqlp.IsQueryParameter)
{
var parm = parameters.Length > i && parameters[i] == sqlp ? parameters[i] : parameters.First(p => p == sqlp);
parms.Add(Parameter(x, parm.Value));
}
}
}
else
{
foreach (var parm in parameters)
{
if (parm.IsQueryParameter && pq.SqlParameters.Contains(parm))
{
var name = DataProvider.Convert(parm.Name, ConvertType.NameToQueryParameter).ToString();
parms.Add(Parameter(name, parm.Value));
}
}
}
pq.Parameters = parms.ToArray();
}
private IEnumerable <DynamicPropertyResult> MoodPropertyCalculator(IQueryContext context, Name x)
// Should only accept SELF, its rpc Name our a variable that should be subbed by its name
{
if (context.Perspective != Name.SELF_SYMBOL)
{
yield break;
}
if (x.IsVariable)
{
foreach (var resultPair in context.AskPossibleProperties(x))
{
var v = m_emotionalState.Mood;
foreach (var c in resultPair.Item2)
{
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(v)), c));
}
}
}
else
{
if (x != Name.SELF_SYMBOL && x != (Name)context.Queryable.Perspective)
{
yield break;
}
var v = m_emotionalState.Mood;
foreach (var c in context.Constraints)
{
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(v)), c));
}
if (!context.Constraints.Any())
{
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(v)), new SubstitutionSet()));
}
}
}
public async Task InvokeAsync(IQueryContext context)
{
if (IsContextIncomplete(context))
{
context.Result = QueryResult.CreateError(
ErrorBuilder.New()
.SetMessage(CoreResources
.ParseQueryMiddleware_InComplete)
.Build());
}
else
{
Activity activity = _diagnosticEvents.BeginParsing(context);
try
{
bool documentRetrievedFromCache = true;
context.CachedQuery = _queryCache.GetOrCreate(
context.Request.Query,
() =>
{
documentRetrievedFromCache = false;
DocumentNode document =
ParseDocument(context.Request.Query);
return(new CachedQuery(
context.Request.Query,
document));
});
context.Document = context.CachedQuery.Document;
context.ContextData[ContextDataKeys.DocumentCached] =
documentRetrievedFromCache;
}
finally
{
_diagnosticEvents.EndParsing(activity, context);
}
}
await _next(context).ConfigureAwait(false);
}
/// <summary>
/// 初始化查询上下文。
/// </summary>
/// <param name="context">查询上下文。</param>
protected override void Init(IQueryContext <Application> context)
{
base.Init(context);
if (!string.IsNullOrWhiteSpace(Name))
{
context.Where(x => x.Name.Contains(Name));
}
if (UserId > 0)
{
context.Where(x => x.UserId == UserId);
}
if (AppId != null && AppId != Guid.Empty)
{
context.Where(x => x.Id == AppId);
}
if (Status != null)
{
context.Where(x => x.Status == Status);
}
context.OrderByDescending(x => x.CreatedDate);
}
public override IEnumerable <IQueryContext> ExecuteQueries(ILog log)
{
IEnumerable <IQueryContext> queries = base.ExecuteQueries(log);
foreach (IQueryContext query in queries)
{
yield return(query);
if (query.QueryType != typeof(RecompileSummary))
{
continue;
}
// Manually add this summary metric
IQueryContext max = GetMaxRecompileSummaryMetric(query.Results);
if (max != null)
{
yield return(max);
}
}
}
private IEnumerable <DynamicPropertyResult> EventIdPropertyCalculator(IQueryContext context, Name type, Name subject, Name def, Name target)
{
var key = Name.BuildName((Name)AMConsts.EVENT, type, subject, def, target);
foreach (var c in context.Constraints)
{
var unifiedSet = m_typeIndexes.Unify(key, c);
foreach (var pair in unifiedSet)
{
foreach (var id in pair.Item1)
{
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(id)), new SubstitutionSet(pair.Item2)));
}
}
if (!unifiedSet.Any())
{
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(-1)), c));
}
}
}
public static bool DropObject(this IQueryContext context, DbObjectType objectType, ObjectName objectName)
{
if (objectType == DbObjectType.Variable &&
context.DropVariable(objectName.Name))
{
return(true);
}
if (objectType == DbObjectType.Cursor &&
context.DropCursor(objectName.Name))
{
return(true);
}
if (!context.UserCanDropObject(objectType, objectName))
{
throw new MissingPrivilegesException(context.UserName(), objectName, Privileges.Drop);
}
context.Session().DropObject(objectType, objectName);
return(true);
}
/// <summary>
/// 初始化查询上下文。
/// </summary>
/// <param name="context">查询上下文。</param>
protected override void Init(IQueryContext <Post> context)
{
context.OrderByDescending(x => x.Id);
if (PostId != null)
{
context.Where(x => x.ParentId == PostId);
}
if (CommentId == 0)
{
context.InnerJoin <Comment>((p, c) => p.CommentId == c.Id)
.Where <Comment>(x => x.TargetId == TargetId && x.ExtensionName == ExtensionName);
}
else
{
context.Where(x => x.CommentId == CommentId);
}
if (Status != null)
{
context.Where(x => x.Status == Status);
}
}
/// <summary>
/// 初始化查询上下文。
/// </summary>
/// <param name="context">查询上下文。</param>
protected override void Init(IQueryContext <Tag> context)
{
if (!string.IsNullOrWhiteSpace(Name))
{
context.Where(x => x.Name.Contains(Name));
}
if (Cid > 0)
{
context.Where(x => x.CategoryId == Cid);
}
switch (Sorter)
{
case TagSorter.Follows:
context.OrderBy(x => x.Follows, IsDesc);
break;
default:
context.OrderBy(x => x.Name, IsDesc);
break;
}
}
public async Task InvokeAsync(IQueryContext context)
{
Activity activity = ParsingDiagnosticEvents.BeginParsing(context);
if (IsContextIncomplete(context))
{
context.Result = QueryResult.CreateError(new QueryError(
"The parse query middleware expects " +
"a valid query request."));
}
else
{
context.Document = _queryCache.GetOrCreate(
context.Request.Query,
() => ParseDocument(context.Request.Query));
await _next(context).ConfigureAwait(false);
}
ParsingDiagnosticEvents.EndParsing(activity, context);
}
public void EndQueryExecute(IQueryContext context)
{
if (!ShouldLog)
{
return;
}
using (var stream = new MemoryStream())
{
var resultSerializer = new JsonQueryResultSerializer();
resultSerializer.SerializeAsync(
(IReadOnlyQueryResult)context.Result,
stream).Wait();
if (Encoding.UTF8.GetString(stream.ToArray()).Contains("String type is most often used by GraphQL to represent free-form human-readable text"))
{
return;
}
_logger.LogInformation("\n" +
Encoding.UTF8.GetString(stream.ToArray()));
}
ShouldLog = false;
}
private IEnumerable <DynamicPropertyResult> EventAgePropertyCalculator(IQueryContext context, Name id)
{
if (id.IsVariable)
{
foreach (var record in m_registry.Values)
{
var idSub = new Substitution(id, new ComplexValue(Name.BuildName(record.Id)));
foreach (var c in context.Constraints)
{
if (c.Conflicts(idSub))
{
continue;
}
var newSet = new SubstitutionSet(c);
newSet.AddSubstitution(idSub);
var value = Tick - record.Timestamp;
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(value)), newSet));
}
}
yield break;
}
foreach (var pair in context.AskPossibleProperties(id))
{
uint idValue;
if (!pair.Item1.Value.TryConvertToValue(out idValue))
{
continue;
}
var record = m_registry[idValue];
var value = (Tick - record.Timestamp);
foreach (var c in pair.Item2)
{
yield return(new DynamicPropertyResult(new ComplexValue(Name.BuildName(value)), c));
}
}
}
public static void DropViews(this IQueryContext context, IEnumerable <ObjectName> viewNames, bool onlyIfExists)
{
var viewNameList = viewNames.ToList();
foreach (var tableName in viewNameList)
{
if (!context.UserCanDropObject(DbObjectType.View, tableName))
{
throw new MissingPrivilegesException(context.UserName(), tableName, Privileges.Drop);
}
}
// If the 'only if exists' flag is false, we need to check tables to drop
// exist first.
if (!onlyIfExists)
{
// For each table to drop.
foreach (var viewName in viewNameList)
{
// If view doesn't exist, throw an error
if (!context.ViewExists(viewName))
{
throw new ObjectNotFoundException(viewName, String.Format("The view '{0}' does not exist and cannot be dropped.", viewName));
}
}
}
foreach (var viewName in viewNameList)
{
// Does the table already exist?
if (context.ViewExists(viewName))
{
// Drop table in the transaction
context.DropObject(DbObjectType.Table, viewName);
// Revoke all the grants on the table
context.RevokeAllGrantsOnView(viewName);
}
}
}
/// <summary>
/// 初始化查询上下文。
/// </summary>
/// <param name="context">查询上下文。</param>
protected override void Init(IQueryContext <Issue> context)
{
context.WithNolock();
if (ProjectId > 0)
{
context.Where(x => x.ProjectId == ProjectId);
}
if (Mid > 0)
{
context.Where(x => x.MilestoneId == Mid);
}
if (UserId > 0)
{
context.Where(x => x.UserId == UserId);
}
if (Operator > 0)
{
context.Where(x => x.Operator == Operator);
}
if (Moderator > 0)
{
context.Where(x => x.Moderator == Moderator);
}
if (Status != null)
{
context.Where(x => x.Status == Status);
}
if (Type != null)
{
context.Where(x => x.Type == Type);
}
if (Level != null)
{
context.Where(x => x.Level == Level);
}
if (!string.IsNullOrEmpty(Title))
{
context.Where(x => x.Title.Contains(Title));
}
}
public async Task InvokeAsync(IQueryContext context)
{
CancellationTokenSource requestTimeoutCts = null;
CancellationTokenSource combinedCts = null;
CancellationToken requestAborted = context.RequestAborted;
if (!Debugger.IsAttached)
{
requestTimeoutCts = new CancellationTokenSource(
_options.ExecutionTimeout);
combinedCts = CancellationTokenSource.CreateLinkedTokenSource(
requestTimeoutCts.Token,
context.RequestAborted);
context.RequestAborted = combinedCts.Token;
}
try
{
await _next(context).ConfigureAwait(false);
}
catch (TaskCanceledException ex)
{
if (requestAborted.IsCancellationRequested)
{
throw;
}
context.Exception = ex;
context.Result = QueryResult.CreateError(
ErrorBuilder.New()
.SetMessage(CoreResources.RequestTimeoutMiddleware_Timeout)
.SetCode(ErrorCodes.Execution.Timeout)
.Build());
}
finally
{
combinedCts?.Dispose();
requestTimeoutCts?.Dispose();
}
}
/// <summary>
/// Calculates a list of <see cref="SelectableRange"/> objects that represent
/// the range of the expression.
/// </summary>
/// <param name="context"></param>
/// <param name="field"></param>
/// <param name="range"></param>
/// <param name="exp"></param>
private static void CalcRange(IQueryContext context, DataColumnInfo field, SelectableRangeSet range, Expression exp)
{
var binary = (BinaryExpression)exp;
Operator op = binary.Operator;
if (op.IsLogical())
{
if (op == Operator.And)
{
IList <Expression> andList = CreateAndList(new List <Expression>(), exp);
foreach (Expression expr in andList)
{
UpdateRange(context, range, field, expr);
}
}
else if (op == Operator.Or)
{
// Split left and right of logical operator.
Expression[] exps = { binary.Left, binary.Right };
// Calculate the range of the left and right
SelectableRangeSet left = new SelectableRangeSet();
CalcRange(context, field, left, exps[0]);
SelectableRangeSet right = new SelectableRangeSet();
CalcRange(context, field, right, exps[1]);
// Union the left and right range with the current range
range.Union(left);
range.Union(right);
}
else
{
throw new ApplicationException("Unrecognised logical operator.");
}
}
else
{
// Not an operator so this is the value.
UpdateRange(context, range, field, exp);
}
}
private async Task LoadPackages()
{
IsEditable = false;
ClearPackages(isErrorCase: true);
CurrentCancellationTokenSource = new CancellationTokenSource();
var usedTokenSource = CurrentCancellationTokenSource;
var repository = GetPackageRepository();
if (repository == null)
{
await LoadPage(CurrentCancellationTokenSource.Token);
return;
}
_currentQuery = new ShowLatestVersionQueryContext <IPackageSearchMetadata>(repository, _currentSearch, ShowPrereleasePackages, PackageListPageSize);
_feedType = await repository.GetFeedType(usedTokenSource.Token);
await LoadPage(CurrentCancellationTokenSource.Token);
}
public Task InvokeAsync(IQueryContext context)
{
string operationName = context.Request.OperationName;
string cacheKey = CreateKey(operationName, context.QueryKey);
OperationDefinitionNode node = _queryCache.GetOrCreate(cacheKey,
() => QueryDocumentHelper.GetOperation(
context.Document, operationName));
ObjectType rootType = ResolveRootType(context, node.Operation);
object rootValue = ResolveRootValue(context, rootType);
var disposeRootValue = false;
if (rootValue == null)
{
rootValue = CreateRootValue(context, rootType);
disposeRootValue = true;
}
var variableBuilder = new VariableValueBuilder(
context.Schema, node);
context.Operation = new Operation(
context.Document, node,
variableBuilder.CreateValues(context.Request.VariableValues),
rootType, rootValue);
try
{
return(_next(context));
}
finally
{
if (disposeRootValue && rootValue is IDisposable d)
{
d.Dispose();
}
}
}
