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 static ColumnChecker Default(IQueryContext context, ObjectName tableName) { var table = context.GetTable(tableName); if (table == null) throw new InvalidOperationException(String.Format("Table '{0}' not found in the context.", tableName)); var tableInfo = table.TableInfo; var ignoreCase = context.IgnoreIdentifiersCase(); return new DefaultChecker(tableInfo, ignoreCase); }
protected virtual bool Authenticate(string defaultSchema, string username, string password) { if (CurrentState == ConnectorState.Authenticated && QueryContext != null) throw new InvalidOperationException("Already authenticated."); // TODO: Log a debug information // TODO: Log an information about the logging user... try { QueryContext = OnAuthenticate(defaultSchema, username, password); if (QueryContext == null) return false; QueryContext.AutoCommit(autoCommit); QueryContext.IgnoreIdentifiersCase(ignoreIdentifiersCase); QueryContext.ParameterStyle(parameterStyle); ChangeState(ConnectorState.Authenticated); return true; } catch (Exception e) { // TODO: throw server error throw; } }
public static QueryExpressionFrom Create(IQueryContext context, SqlQueryExpression expression) { // Get the 'from_clause' from the table expression var fromClause = expression.FromClause; var ignoreCase = context.IgnoreIdentifiersCase(); var queryFrom = new QueryExpressionFrom(ignoreCase); foreach (var fromTable in fromClause.AllTables) { var uniqueKey = fromTable.UniqueKey; var alias = fromTable.Alias; if (fromTable.IsSubQuery) { // eg. FROM ( SELECT id FROM Part ) var subQuery = fromTable.SubQuery; var subQueryFrom = Create(context, subQuery); // The aliased name of the table ObjectName aliasTableName = null; if (alias != null) aliasTableName = new ObjectName(alias); // Add to list of sub-query tables to add to command, queryFrom.AddTable(new FromTableSubQuerySource(ignoreCase, uniqueKey, subQuery, subQueryFrom, aliasTableName)); } else { // Else must be a standard command table, string name = fromTable.Name; // Resolve to full table name var tableName = context.ResolveTableName(name); if (!context.TableExists(tableName)) throw new InvalidOperationException(String.Format("Table '{0}' was not found.", tableName)); ObjectName givenName = null; if (alias != null) givenName = new ObjectName(alias); // Get the ITableQueryInfo object for this table name (aliased). ITableQueryInfo tableQueryInfo = context.GetTableQueryInfo(tableName, givenName); queryFrom.AddTable(new FromTableDirectSource(ignoreCase, tableQueryInfo, uniqueKey, givenName, tableName)); } } // Set up functions, aliases and exposed variables for this from set, foreach (var selectColumn in expression.SelectColumns) { // Is this a glob? (eg. Part.* ) if (selectColumn.IsGlob) { // Find the columns globbed and add to the 'selectedColumns' result. if (selectColumn.IsAll) { queryFrom.ExposeAllColumns(); } else { // Otherwise the glob must be of the form '[table name].*' queryFrom.ExposeColumns(selectColumn.TableName); } } else { // Otherwise must be a standard column reference. Note that at this // time we aren't sure if a column expression is correlated and is // referencing an outer source. This means we can't verify if the // column expression is valid or not at this point. // If this column is aliased, add it as a function reference to the // select expression string alias = selectColumn.Alias; var v = selectColumn.Expression.AsReferenceName(); bool aliasMatchV = (v != null && alias != null && queryFrom.CompareStrings(v.Name, alias)); if (alias != null && !aliasMatchV) { queryFrom.AddExpression(new ExpressionReference(selectColumn.Expression, alias)); queryFrom.ExposeColumn(new ObjectName(alias)); } else if (v != null) { var resolved = queryFrom.ResolveReference(v); queryFrom.ExposeColumn(resolved ?? v); } else { string funName = selectColumn.Expression.ToString(); queryFrom.AddExpression(new ExpressionReference(selectColumn.Expression, funName)); queryFrom.ExposeColumn(new ObjectName(funName)); } } } return queryFrom; }
public bool CheckColumnNamesMatch(IQueryContext db, String col1, String col2) { var comparison = db.IgnoreIdentifiersCase() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; return col1.Equals(col2, comparison); }
internal override bool MatchesInvoke(Invoke request, IQueryContext queryContext) { if (request == null) return false; bool ignoreCase = true; if (queryContext != null) ignoreCase = queryContext.IgnoreIdentifiersCase(); if (!RoutineName.Equals(request.RoutineName, ignoreCase)) return false; // TODO: add a better resolution to obtain the final type of the argument // and compare it to the parameter type definition bool unboundedSeen = false; for (int i = 0; i < request.Arguments.Length; i++) { var argType = request.Arguments[i].ReturnType(queryContext, null); if (i + 1 > Parameters.Length) { if (!unboundedSeen) return false; // TODO: verify the type of the argument (how to evaluate?) } else { var param = Parameters[i]; unboundedSeen = param.IsUnbounded; var paramType = param.Type; if (!paramType.IsComparable(argType)) return false; } } if (!unboundedSeen && request.Arguments.Length != Parameters.Length) return false; return true; }
private DataObject Evaluate(SqlExpression expression, IQueryContext queryContext) { var ignoreCase = queryContext.IgnoreIdentifiersCase(); // Resolve any variables to the table_def for this expression. expression = Table.TableInfo.ResolveColumns(ignoreCase, expression); // Get the variable resolver and evaluate over this data. IVariableResolver vresolver = VariableResolver; var reduced = expression.Evaluate(queryContext, vresolver, null); if (reduced.ExpressionType != SqlExpressionType.Constant) throw new InvalidOperationException("The DEFAULT expression of the column cannot be reduced to a constant"); return ((SqlConstantExpression) reduced).Value; }