protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); if (!context.Access().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.Query.Context.QueryPlanner().PlanQuery(new QueryInfo(context, queryExpression)); 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)); }
public static SqlNumber NextValue(IRequest request, SqlString sequenceName) { var objName = ObjectName.Parse(sequenceName.ToString()); var resolvedName = request.Access().ResolveObjectName(DbObjectType.Sequence, objName); return(request.Access().GetNextValue(resolvedName)); }
public static SqlNumber CurrentKey(IRequest request, SqlString tableName) { var tableNameString = tableName.ToString(); var resolvedName = request.Access().ResolveTableName(tableNameString); return(request.Access().GetCurrentValue(resolvedName)); }
public static SqlNumber CurrentValue(IRequest query, SqlString sequenceName) { var objName = ObjectName.Parse(sequenceName.ToString()); var resolvedName = query.Access().ResolveObjectName(DbObjectType.Sequence, objName); return(query.Access().GetCurrentValue(resolvedName)); }
protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); if (!context.Access().TableExists(tableName)) { throw new ObjectNotFoundException(tableName); } var queryExp = new SqlQueryExpression(new SelectColumn[] { SelectColumn.Glob("*") }); queryExp.FromClause.AddTable(tableName.FullName); queryExp.WhereExpression = WhereExpression; var queryInfo = new QueryInfo(context, queryExp); if (Limit > 0) { queryInfo.Limit = new QueryLimit(Limit); } var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(queryInfo); return(new Prepared(tableName, queryPlan)); }
protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); if (!context.Access().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.Query.Context.QueryPlanner().PlanQuery(new QueryInfo(context, queryExpression)); 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); }
protected override SqlStatement PrepareStatement(IRequest context) { var reference = ReferenceExpression; if (ReferenceExpression is SqlReferenceExpression) { var referenceName = ((SqlReferenceExpression)ReferenceExpression).ReferenceName; if (referenceName.Parent == null && context.Context.CursorExists(referenceName.Name)) { reference = SqlExpression.VariableReference(referenceName.Name); } else { var tableName = context.Access().ResolveTableName(referenceName); if (!context.Access().TableExists(tableName)) { throw new ObjectNotFoundException(tableName, "Reference table for the FETCH INTO clause was not found."); } reference = SqlExpression.Reference(tableName); } } return(new FetchIntoStatement(CursorName, Direction, OffsetExpression, reference)); }
protected override SqlStatement PrepareStatement(IRequest context) { var schemaName = context.Access().ResolveSchemaName(TriggerName.ParentName); var triggerName = new ObjectName(schemaName, TriggerName.Name); var tableName = context.Access().ResolveTableName(TableName); return(new CreateTriggerStatement(triggerName, tableName, Body, EventTime, EventType)); }
public override ITable Evaluate(IRequest context) { // Is the result available in the context? var childTable = context.Access().GetCachedTable(Id.ToString()); if (childTable == null) { // No so evaluate the child and cache it childTable = Child.Evaluate(context); context.Access().CacheTable(Id.ToString(), childTable); } return childTable; }
protected override SqlStatement PrepareStatement(IRequest context) { var viewName = context.Access().ResolveObjectName(DbObjectType.View, ViewName); if (!IfExists && !context.Access().ViewExists(viewName)) { throw new ObjectNotFoundException(ViewName); } return(new DropViewStatement(viewName, IfExists)); }
protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); if (tableName == null) { throw new ObjectNotFoundException(TableName); } var columns = new string[0]; if (ColumnNames != null) { columns = ColumnNames.ToArray(); } ITableQueryInfo tableQueryInfo = context.Access().GetTableQueryInfo(tableName, null); var fromTable = new FromTableDirectSource(context.Query.IgnoreIdentifiersCase(), tableQueryInfo, "INSERT_TABLE", tableName, tableName); // Get the table we are inserting to var insertTable = context.Access().GetTable(tableName); if (columns.Length == 0) { columns = new string[insertTable.TableInfo.ColumnCount]; for (int i = 0; i < columns.Length; i++) { columns[i] = insertTable.TableInfo[i].ColumnName; } } var colIndices = new int[columns.Length]; var colResolved = new ObjectName[columns.Length]; for (int i = 0; i < columns.Length; ++i) { var inVar = new ObjectName(columns[i]); var col = ResolveColumn(fromTable, inVar); int index = insertTable.FindColumn(col); if (index == -1) { throw new InvalidOperationException(String.Format("Cannot find column '{0}' in table '{1}'.", col, tableName)); } colIndices[i] = index; colResolved[i] = col; } var queryPlan = context.Context.QueryPlanner().PlanQuery(new QueryInfo(context, QueryExpression)); return(new Prepared(tableName, colResolved, colIndices, queryPlan)); }
protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); if (!context.Access().TableExists(tableName) && !IfExists) { throw new ObjectNotFoundException(TableName); } return(new DropTableStatement(tableName, IfExists)); }
/// <summary> /// Checks if the target of the invocation is an aggregate function. /// </summary> /// <param name="query">The query context used to resolve the routine.</param> /// <returns> /// Returns <c>true</c> if the target routine of the invocation is a <see cref="IFunction"/> /// and the <see cref="IFunction.FunctionType"/> is <see cref="FunctionType.Aggregate"/>, /// otherwise it returns <c>false</c>. /// </returns> public bool IsAggregate(IRequest query) { var resolvedName = query.Access().ResolveObjectName(DbObjectType.Routine, RoutineName); var invoke = new Invoke(resolvedName, Arguments); if (query.Access().IsAggregateFunction(invoke, query)) { return(true); } // Look at parameterss return(Arguments.Any(x => x.Value.HasAggregate(query))); }
public override ITable Evaluate(IRequest context) { // Is the result available in the context? var childTable = context.Access().GetCachedTable(Id.ToString()); if (childTable == null) { // No so evaluate the child and cache it childTable = Child.Evaluate(context); context.Access().CacheTable(Id.ToString(), childTable); } return(childTable); }
protected override SqlStatement PrepareStatement(IRequest context) { var triggerSchemaName = context.Access().ResolveSchemaName(TriggerName.ParentName); var triggerName = new ObjectName(triggerSchemaName, TriggerName.Name); var tableName = context.Access().ResolveTableName(TableName); var procedureName = context.Access().ResolveObjectName(DbObjectType.Routine, ProcedureName); return(new CreateProcedureTriggerStatement(triggerName, tableName, procedureName, ProcedureArguments, EventTime, EventType) { ReplaceIfExists = ReplaceIfExists, Status = Status }); }
protected override SqlStatement PrepareStatement(IRequest context) { ObjectName tableName = null; if (Target == ShowTarget.Table && TableName != null) { tableName = context.Access().ResolveTableName(TableName); } if (Target == ShowTarget.Schema) { return(ShowSchema()); } if (Target == ShowTarget.SchemaTables) { return(ShowSchemaTables(context.Query.CurrentSchema())); } if (Target == ShowTarget.Table) { return(ShowTable(tableName)); } if (Target == ShowTarget.Product) { return(ShowProduct()); } throw new StatementException(String.Format("The SHOW target {0} is not supported.", Target)); }
/// <summary> /// Resolves the routine target of the invocation within the give context. /// </summary> /// <param name="context">The query context used to resolve the routine.</param> /// <remarks> /// <para> /// If the given <paramref name="context"/> is <c>null</c> this method will /// try to resolve the routine towards the /// </para> /// </remarks> /// <returns> /// Returns an instance of <see cref="IRoutine"/> that is the target of the invocation. /// </returns> /// <exception cref="InvalidOperationException"> /// If the routine could not be resolved for this call. /// </exception> public IRoutine ResolveRoutine(IRequest context) { if (cached != null) { return(cached); } if (context == null) { cached = SystemFunctions.Provider.ResolveFunction(this, null); } else { var resolvedName = context.Access().ResolveObjectName(DbObjectType.Routine, RoutineName); var invoke = new Invoke(resolvedName, Arguments); cached = context.Query.Access().ResolveRoutine(invoke, context); } if (cached == null) { throw new InvalidOperationException(String.Format("Unable to resolve the call {0} to a function", this)); } return(cached); }
public override ITable Evaluate(IRequest context) { ITable childTable = Child.Evaluate(context); context.Access().CacheTable(MarkName, childTable); return(childTable); }
private TableInfo CreateTableInfo(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); var idColumnCount = Columns.Count(x => x.IsIdentity); if (idColumnCount > 1) { throw new InvalidOperationException("More than one IDENTITY column specified."); } bool ignoreCase = context.Query.IgnoreIdentifiersCase(); var columnChecker = new TableColumnChecker(Columns, ignoreCase); var tableInfo = new TableInfo(tableName); foreach (var column in Columns) { var columnInfo = CreateColumnInfo(context, tableName.Name, column, columnChecker); if (column.IsIdentity) { columnInfo.DefaultExpression = SqlExpression.FunctionCall("UNIQUEKEY", new SqlExpression[] { SqlExpression.Constant(tableName.ToString()) }); } tableInfo.AddColumn(columnInfo); } return(tableInfo); }
protected override SqlStatement PrepareStatement(IRequest context) { var viewName = context.Access().ResolveTableName(ViewName); var queryFrom = QueryExpressionFrom.Create(context, QueryExpression); var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(new QueryInfo(context, QueryExpression)); var colList = ColumnNames == null ? new string[0] : ColumnNames.ToArray(); // Wrap the result around a SubsetNode to alias the columns in the // table correctly for this view. int sz = colList.Length; var originalNames = queryFrom.GetResolvedColumns(); var newColumnNames = new ObjectName[originalNames.Length]; if (sz > 0) { if (sz != originalNames.Length) { throw new InvalidOperationException("Column list is not the same size as the columns selected."); } for (int i = 0; i < sz; ++i) { var colName = colList[i]; newColumnNames[i] = new ObjectName(viewName, colName); } } else { sz = originalNames.Length; for (int i = 0; i < sz; ++i) { newColumnNames[i] = new ObjectName(viewName, originalNames[i].Name); } } // Check there are no repeat column names in the table. for (int i = 0; i < sz; ++i) { var columnName = newColumnNames[i]; for (int n = i + 1; n < sz; ++n) { if (newColumnNames[n].Equals(columnName)) { throw new InvalidOperationException(String.Format("Duplicate column name '{0}' in view. A view may not contain duplicate column names.", columnName)); } } } // Wrap the plan around a SubsetNode plan queryPlan = new SubsetNode(queryPlan, originalNames, newColumnNames); return(new Prepared(viewName, QueryExpression, queryPlan, ReplaceIfExists)); }
public static ColumnChecker Default(IRequest context, ObjectName tableName) { var table = context.Access().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.Query.IgnoreIdentifiersCase(); return new DefaultChecker(tableInfo, ignoreCase); }
protected override SqlStatement PrepareStatement(IRequest context) { var triggerName = context.Access().ResolveObjectName(DbObjectType.Trigger, TriggerName); var action = Action; if (action is IStatementPreparable) { action = (IAlterTriggerAction)(action as IStatementPreparable).Prepare(context); } return(new AlterTriggerStatement(triggerName, action)); }
protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); var action = Action; if (action is IStatementPreparable) { action = (IAlterTableAction)((IStatementPreparable)Action).Prepare(context); } return(new AlterTableStatement(tableName, action)); }
protected override SqlStatement PrepareStatement(IRequest context) { var objectName = context.Access().ResolveTableName(ObjectName); if (objectName == null) { throw new ObjectNotFoundException(ObjectName); } var columns = (Columns != null ? Columns.ToArray() : null); return(new RevokePrivilegesStatement(Grantee, Privileges, GrantOption, objectName, columns)); }
protected override SqlStatement PrepareStatement(IRequest context) { var schemaName = context.Access().ResolveSchemaName(TypeName.ParentName); var typeName = new ObjectName(schemaName, TypeName.Name); var statement = new CreateTypeStatement(typeName, Members, ReplaceIfExists) { IsSealed = IsSealed, IsAbstract = IsAbstract }; var parentName = ParentTypeName; if (parentName != null) { parentName = context.Access().ResolveObjectName(DbObjectType.Type, parentName); } statement.ParentTypeName = parentName; return(statement); }
public static ColumnChecker Default(IRequest context, ObjectName tableName) { var table = context.Access().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.Query.IgnoreIdentifiersCase(); return(new DefaultChecker(tableInfo, ignoreCase)); }
protected override SqlStatement PrepareStatement(IRequest context) { var schemaName = context.Access().ResolveSchemaName(SequenceName.ParentName); var seqName = new ObjectName(schemaName, SequenceName.Name); return(new CreateSequenceStatement(seqName) { StartWith = StartWith, IncrementBy = IncrementBy, Cache = Cache, MinValue = MinValue, MaxValue = MaxValue, Cycle = Cycle }); }
protected override SqlStatement PrepareStatement(IRequest context) { var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(new QueryInfo(context, QueryExpression)); if (Reference is SqlReferenceExpression) { var objName = ((SqlReferenceExpression)Reference).ReferenceName; objName = context.Access().ResolveObjectName(objName); return(new SelectIntoTable(objName, queryPlan)); } if (Reference is SqlVariableReferenceExpression) { var refName = ((SqlVariableReferenceExpression)Reference).VariableName; return(new SelectIntoVariable(new[] { refName }, queryPlan)); } if (Reference is SqlTupleExpression) { var exps = ((SqlTupleExpression)Reference).Expressions; if (exps == null || exps.Length == 0) { throw new StatementException("Empty tuple in SELECT INTO"); } var variables = new List <string>(); for (int i = 0; i < exps.Length; i++) { if (!(exps[i] is SqlVariableReferenceExpression)) { throw new StatementException("Found an invalid expression in the tuple."); } var varName = ((SqlVariableReferenceExpression)exps[i]).VariableName; variables.Add(varName); } return(new SelectIntoVariable(variables.ToArray(), queryPlan)); } // Other (impossible) case... throw new NotSupportedException(); }
public override ITable Evaluate(IRequest context) { // Evaluate the child branch, var result = Child.Evaluate(context); // Get the table of the complete mark name, var completeLeft = context.Access().GetCachedTable(MarkerName); // The rows in 'complete_left' that are outside (not in) the rows in the // left result. var outside = completeLeft.OuterJoin(result); // Create an OuterTable var outerTable = OuterTable.Create(result); outerTable.MergeIn(outside); // Return the outer table return(outerTable); }
protected override SqlStatement PrepareStatement(IRequest context) { ObjectName tableName = null; if (Target == ShowTarget.Table && TableName != null) { tableName = context.Access().ResolveTableName(TableName); } if (Target == ShowTarget.Schema) return ShowSchema(); if (Target == ShowTarget.SchemaTables) return ShowSchemaTables(context.Query.CurrentSchema()); if (Target == ShowTarget.Table) return ShowTable(tableName); if (Target == ShowTarget.Product) return ShowProduct(); throw new StatementException(String.Format("The SHOW target {0} is not supported.", Target)); }
protected override SqlStatement PrepareStatement(IRequest context) { var schemaName = context.Access().ResolveSchemaName(ProcedureName.ParentName); var functionName = new ObjectName(schemaName, ProcedureName.Name); var parameters = new List <RoutineParameter>(); if (Parameters != null) { foreach (var parameter in Parameters) { parameters.Add((RoutineParameter)((IStatementPreparable)parameter).Prepare(context)); } } return(new CreateExternalProcedureStatement(functionName, parameters.ToArray(), ExternalReference) { ReplaceIfExists = ReplaceIfExists }); }
private ITable Evaluate(IRequest context, SqlExpression[] args, out IList <IDbObject> refs) { try { var prepared = PrepareQuery(args); var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(new QueryInfo(context, prepared)); var refNames = queryPlan.DiscoverAccessedResources(); refs = refNames.Select(x => context.Access().FindObject(x.ResourceName)).ToArray(); context.Query.Session.Enter(refs, AccessType.Read); var tables = refs.Where(x => x.ObjectInfo.ObjectType == DbObjectType.Table).Select(x => x.ObjectInfo.FullName); foreach (var table in tables) { context.Query.Session.Transaction.GetTableManager().SelectTable(table); } return(queryPlan.Evaluate(context)); } catch (CursorException) { throw; } catch (Exception ex) { throw new CursorException(CursorInfo.CursorName, ex); } }
protected override SqlStatement PrepareStatement(IRequest context) { var schemaName = context.Access().ResolveSchemaName(FunctionName.ParentName); var functionName = new ObjectName(schemaName, FunctionName.Name); var returnType = ReturnType.Resolve(context); var parameters = new List <RoutineParameter>(); if (Parameters != null) { foreach (var parameter in Parameters) { parameters.Add((RoutineParameter)((IStatementPreparable)parameter).Prepare(context)); } } var body = (PlSqlBlockStatement)Body.Prepare(context); return(new CreateFunctionStatement(functionName, returnType, parameters.ToArray(), body) { ReplaceIfExists = ReplaceIfExists }); }
protected override SqlStatement PrepareStatement(IRequest context) { var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(new QueryInfo(context, QueryExpression)); if (Reference is SqlReferenceExpression) { var objName = ((SqlReferenceExpression) Reference).ReferenceName; objName = context.Access().ResolveObjectName(objName); return new SelectIntoTable(objName, queryPlan); } if (Reference is SqlVariableReferenceExpression) { var refName = ((SqlVariableReferenceExpression) Reference).VariableName; return new SelectIntoVariable(new[] { refName}, queryPlan); } if (Reference is SqlTupleExpression) { var exps = ((SqlTupleExpression) Reference).Expressions; if (exps == null || exps.Length == 0) throw new StatementException("Empty tuple in SELECT INTO"); var variables = new List<string>(); for (int i = 0; i < exps.Length; i++) { if (!(exps[i] is SqlVariableReferenceExpression)) throw new StatementException("Found an invalid expression in the tuple."); var varName = ((SqlVariableReferenceExpression) exps[i]).VariableName; variables.Add(varName); } return new SelectIntoVariable(variables.ToArray(), queryPlan); } // Other (impossible) case... throw new NotSupportedException(); }
public static Field NewObject(IRequest context, Field typeName, Field[] args = null) { if (Field.IsNullField(typeName)) { throw new ArgumentNullException("typeName"); } if (!(typeName.Type is StringType)) { throw new ArgumentException("The type name argument must be of string type."); } var argExp = new SqlExpression[args == null ? 0 : args.Length]; if (args != null) { argExp = args.Select(SqlExpression.Constant).Cast <SqlExpression>().ToArray(); } var type = context.Access().ResolveUserType(typeName.Value.ToString()); if (type == null) { throw new InvalidOperationException(String.Format("The type '{0}' was not defined.", typeName)); } if (!(type is UserType)) { throw new InvalidOperationException(String.Format("The type '{0}' is not a user-defined type", typeName)); } var userType = (UserType)type; var obj = userType.NewObject(context, argExp); return(Field.Object(userType, obj)); }
object IStatementPreparable.Prepare(IRequest request) { var name = request.Access().ResolveObjectName(DbObjectType.Trigger, Name); return new RenameTriggerAction(name); }
protected override SqlStatement PrepareStatement(IRequest context) { var procedureName = context.Access().ResolveObjectName(DbObjectType.Routine, ProcedureName); return new DropProcedureStatement(procedureName, IfExists); }
public static SqlNumber UniqueKey(IRequest request, SqlString tableName) { var tableNameString = tableName.ToString(); var resolvedName = request.Access().ResolveTableName(tableNameString); return request.Access().GetNextValue(resolvedName); }
/// <summary> /// Checks if the target of the invocation is an aggregate function. /// </summary> /// <param name="query">The query context used to resolve the routine.</param> /// <returns> /// Returns <c>true</c> if the target routine of the invocation is a <see cref="IFunction"/> /// and the <see cref="IFunction.FunctionType"/> is <see cref="FunctionType.Aggregate"/>, /// otherwise it returns <c>false</c>. /// </returns> public bool IsAggregate(IRequest query) { var resolvedName = query.Access().ResolveObjectName(DbObjectType.Routine, RoutineName); var invoke = new Invoke(resolvedName, Arguments); if (query.Access().IsAggregateFunction(invoke, query)) return true; // Look at parameterss return Arguments.Any(x => x.Value.HasAggregate(query)); }
protected override SqlStatement PrepareStatement(IRequest context) { var schemaName = context.Access().ResolveSchemaName(FunctionName.ParentName); var functionName = new ObjectName(schemaName, FunctionName.Name); var returnType = ReturnType.Resolve(context); var parameters = new List<RoutineParameter>(); if (Parameters != null) { foreach (var parameter in Parameters) { parameters.Add((RoutineParameter)((IStatementPreparable)parameter).Prepare(context)); } } var body = (PlSqlBlockStatement) Body.Prepare(context); return new CreateFunctionStatement(functionName, returnType, parameters.ToArray(), body) { ReplaceIfExists = ReplaceIfExists }; }
protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); var action = Action; if (action is IStatementPreparable) action = (IAlterTableAction) ((IStatementPreparable) Action).Prepare(context); return new AlterTableStatement(tableName, action); }
protected override SqlStatement PrepareStatement(IRequest context) { var objectName = context.Access().ResolveTableName(ObjectName); if (objectName == null) throw new ObjectNotFoundException(ObjectName); var columns = (Columns != null ? Columns.ToArray() : null); return new RevokePrivilegesStatement(Grantee, Privileges, GrantOption, objectName, columns); }
private IQueryPlanNode CreateChildNode(IRequest context) { return context.Access().GetViewQueryPlan(ViewName); }
protected override SqlStatement PrepareStatement(IRequest context) { var schemaName = context.Access().ResolveSchemaName(TypeName.ParentName); var typeName = new ObjectName(schemaName, TypeName.Name); var statement = new CreateTypeStatement(typeName, Members, ReplaceIfExists) { IsSealed = IsSealed, IsAbstract = IsAbstract }; var parentName = ParentTypeName; if (parentName != null) { parentName = context.Access().ResolveObjectName(DbObjectType.Type, parentName); } statement.ParentTypeName = parentName; return statement; }
public override SqlType Resolve(IRequest context) { return context.Access().ResolveFieldType(FieldName); }
public static SqlNumber NextValue(IRequest request, SqlString sequenceName) { var objName = ObjectName.Parse(sequenceName.ToString()); var resolvedName = request.Access().ResolveObjectName(DbObjectType.Sequence, objName); return request.Access().GetNextValue(resolvedName); }
private TableInfo CreateTableInfo(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); var idColumnCount = Columns.Count(x => x.IsIdentity); if (idColumnCount > 1) throw new InvalidOperationException("More than one IDENTITY column specified."); bool ignoreCase = context.Query.IgnoreIdentifiersCase(); var columnChecker = new TableColumnChecker(Columns, ignoreCase); var tableInfo = new TableInfo(tableName); foreach (var column in Columns) { var columnInfo = CreateColumnInfo(context, tableName.Name, column, columnChecker); if (column.IsIdentity) columnInfo.DefaultExpression = SqlExpression.FunctionCall("UNIQUEKEY", new SqlExpression[] { SqlExpression.Constant(tableName.ToString()) }); tableInfo.AddColumn(columnInfo); } return tableInfo; }
public static SqlNumber CurrentValue(IRequest query, SqlString sequenceName) { var objName = ObjectName.Parse(sequenceName.ToString()); var resolvedName = query.Access().ResolveObjectName(DbObjectType.Sequence, objName); return query.Access().GetCurrentValue(resolvedName); }
protected override SqlStatement PrepareStatement(IRequest context) { var schemaName = context.Access().ResolveSchemaName(ProcedureName.ParentName); var functionName = new ObjectName(schemaName, ProcedureName.Name); var parameters = new List<RoutineParameter>(); if (Parameters != null) { foreach (var parameter in Parameters) { parameters.Add((RoutineParameter)((IStatementPreparable)parameter).Prepare(context)); } } return new CreateExternalProcedureStatement(functionName, parameters.ToArray(), ExternalReference) { ReplaceIfExists = ReplaceIfExists }; }
protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); if (!context.Access().TableExists(tableName)) throw new ObjectNotFoundException(tableName); var queryExp = new SqlQueryExpression(new SelectColumn[] {SelectColumn.Glob("*") }); queryExp.FromClause.AddTable(tableName.FullName); queryExp.WhereExpression = WhereExpression; var queryInfo = new QueryInfo(context, queryExp); if (Limit > 0) queryInfo.Limit = new QueryLimit(Limit); var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(queryInfo); return new Prepared(tableName, queryPlan); }
protected override SqlStatement PrepareStatement(IRequest context) { var tableName = context.Access().ResolveTableName(TableName); return new DeleteCurrentStatement(tableName, CursorName); }
protected override SqlStatement PrepareStatement(IRequest context) { var triggerName = context.Access().ResolveObjectName(DbObjectType.Trigger, TriggerName); var action = Action; if (action is IStatementPreparable) action = (IAlterTriggerAction) (action as IStatementPreparable).Prepare(context); return new AlterTriggerStatement(triggerName, action); }
protected override SqlStatement PrepareStatement(IRequest context) { var triggerName = context.Access().ResolveObjectName(DbObjectType.Trigger, TriggerName); return new DropTriggerStatement(triggerName); }
public static Field NewObject(IRequest context, Field typeName, Field[] args = null) { if (Field.IsNullField(typeName)) throw new ArgumentNullException("typeName"); if (!(typeName.Type is StringType)) throw new ArgumentException("The type name argument must be of string type."); var argExp = new SqlExpression[args == null ? 0 : args.Length]; if (args != null) { argExp = args.Select(SqlExpression.Constant).Cast<SqlExpression>().ToArray(); } var type = context.Access().ResolveUserType(typeName.Value.ToString()); if (type == null) throw new InvalidOperationException(String.Format("The type '{0}' was not defined.", typeName)); if (!(type is UserType)) throw new InvalidOperationException(String.Format("The type '{0}' is not a user-defined type", typeName)); var userType = (UserType) type; var obj = userType.NewObject(context, argExp); return Field.Object(userType, obj); }
protected override SqlStatement PrepareStatement(IRequest context) { var triggerSchemaName = context.Access().ResolveSchemaName(TriggerName.ParentName); var triggerName = new ObjectName(triggerSchemaName, TriggerName.Name); var tableName = context.Access().ResolveTableName(TableName); var procedureName = context.Access().ResolveObjectName(DbObjectType.Routine, ProcedureName); return new CreateProcedureTriggerStatement(triggerName, tableName, procedureName, ProcedureArguments, EventTime, EventType) { ReplaceIfExists = ReplaceIfExists, Status = Status }; }
protected override SqlStatement PrepareStatement(IRequest context) { var viewName = context.Access().ResolveObjectName(DbObjectType.View, ViewName); if (!IfExists && !context.Access().ViewExists(viewName)) throw new ObjectNotFoundException(ViewName); return new DropViewStatement(viewName, IfExists); }
public override SqlType Resolve(IRequest context) { return context.Access().ResolveRowType(ObjectName); }
public override ITable Evaluate(IRequest context) { // Evaluate the child branch, var result = Child.Evaluate(context); // Get the table of the complete mark name, var completeLeft = context.Access().GetCachedTable(MarkerName); // The rows in 'complete_left' that are outside (not in) the rows in the // left result. var outside = completeLeft.OuterJoin(result); // Create an OuterTable var outerTable = OuterTable.Create(result); outerTable.MergeIn(outside); // Return the outer table return outerTable; }
/// <summary> /// Resolves the routine target of the invocation within the give context. /// </summary> /// <param name="context">The query context used to resolve the routine.</param> /// <remarks> /// <para> /// If the given <paramref name="context"/> is <c>null</c> this method will /// try to resolve the routine towards the /// </para> /// </remarks> /// <returns> /// Returns an instance of <see cref="IRoutine"/> that is the target of the invocation. /// </returns> /// <exception cref="InvalidOperationException"> /// If the routine could not be resolved for this call. /// </exception> public IRoutine ResolveRoutine(IRequest context) { if (cached != null) return cached; if (context == null) { cached = SystemFunctions.Provider.ResolveFunction(this, null); } else { var resolvedName = context.Access().ResolveObjectName(DbObjectType.Routine, RoutineName); var invoke = new Invoke(resolvedName, Arguments); cached = context.Query.Access().ResolveRoutine(invoke, context); } if (cached == null) throw new InvalidOperationException(String.Format("Unable to resolve the call {0} to a function", this)); return cached; }
public ITable Evaluate(IRequest context) { var t = context.Access().GetTable(TableName); return AliasName != null ? new ReferenceTable(t, AliasName) : t; }