public override void DetermineDataType(Plan plan) { DetermineModifiers(plan); if (!Nodes[1].IsRepeatable) { throw new CompilerException(CompilerException.Codes.InvalidRestrictionCondition); } _dataType = new Schema.TableType(); _tableVar = new Schema.ResultTableVar(this); _tableVar.Owner = plan.User; _tableVar.InheritMetaData(SourceTableVar.MetaData); CopyTableVarColumns(SourceTableVar.Columns); DetermineRemotable(plan); DetermineSargability(plan); CopyKeys(SourceTableVar.Keys); int columnIndex; foreach (ColumnConditions condition in _conditions) { foreach (ColumnCondition columnCondition in condition) { if (columnCondition.Instruction == Instructions.Equal) { foreach (Schema.Key key in _tableVar.Keys) { columnIndex = key.Columns.IndexOfName(condition.Column.Name); if (columnIndex >= 0) { key.Columns.RemoveAt(columnIndex); // A key reduced to the empty key by restriction is no longer sparse if (key.Columns.Count == 0) { key.IsSparse = false; } } } } } } RemoveSuperKeys(); CopyOrders(SourceTableVar.Orders); #if UseReferenceDerivation #if UseElaborable if (plan.CursorContext.CursorCapabilities.HasFlag(CursorCapability.Elaborable)) #endif CopyReferences(plan, SourceTableVar); #endif if ((Order == null) && (SourceNode.Order != null)) { Order = CopyOrder(SourceNode.Order); } }
public override void DetermineDataType(Plan plan) { DetermineModifiers(plan); _dataType = new Schema.TableType(); _tableVar = new Schema.ResultTableVar(this); _tableVar.Owner = plan.User; DataType.Columns.Add(new Schema.Column("Sequence", plan.DataTypes.SystemInteger)); DataType.Columns.Add(new Schema.Column("LogName", plan.DataTypes.SystemString)); foreach (Schema.Column column in DataType.Columns) { TableVar.Columns.Add(new Schema.TableVarColumn(column)); } TableVar.Keys.Add(new Schema.Key(new Schema.TableVarColumn[] { TableVar.Columns["Sequence"] })); TableVar.DetermineRemotable(plan.CatalogDeviceSession); Order = Compiler.FindClusteringOrder(plan, TableVar); // Ensure the order exists in the orders list if (!TableVar.Orders.Contains(Order)) { TableVar.Orders.Add(Order); } }
protected override void InternalClose() { while (_sourceTables.Count > 0) { PopSourceTable(); } if (_sourceRow != null) { _sourceRow.Dispose(); _sourceRow = null; } if (_targetRow != null) { _targetRow.Dispose(); _targetRow = null; } if (_scan != null) { _scan.Dispose(); _scan = null; } if (_buffer != null) { _buffer.Drop(Manager); _buffer = null; } _tableType = null; _sequenceColumnIndex = -1; }
public override void DetermineDataType(Plan plan) { DetermineModifiers(plan); _dataType = new Schema.TableType(); _tableVar = new Schema.ResultTableVar(this); _tableVar.Owner = plan.User; _tableVar.InheritMetaData(SourceTableVar.MetaData); CopyTableVarColumns(SourceTableVar.Columns); DetermineRemotable(plan); CopyKeys(SourceTableVar.Keys); CopyOrders(SourceTableVar.Orders); #if UseReferenceDerivation #if UseElaborable if (plan.CursorContext.CursorCapabilities.HasFlag(CursorCapability.Elaborable)) #endif CopyReferences(plan, SourceTableVar); #endif DetermineOrder(plan); // Ensure the order exists in the orders list if (!TableVar.Orders.Contains(Order)) { TableVar.Orders.Add(Order); } }
public override void DetermineDataType(Plan plan) { base.DetermineDataType(plan); if (Nodes[0].DataType is Schema.ScalarType) { Schema.TableType tableType = (Schema.TableType)Nodes[1].DataType; if (tableType.Columns.Count != 1) { throw new CompilerException(CompilerException.Codes.InvalidMembershipOperand, plan.CurrentStatement(), Nodes[0].DataType.Name, Nodes[1].DataType.Name); } #if USECOLUMNLOCATIONBINDING FEqualNode = Compiler.EmitBinaryNode ( APlan, new StackReferenceNode(Nodes[0].DataType, 1, true), Instructions.Equal, new StackColumnReferenceNode(tableType.Columns[0].DataType, 0, 0) ); #else _equalNode = Compiler.EmitBinaryNode ( plan, new StackReferenceNode(Nodes[0].DataType, 1, true), Instructions.Equal, new StackColumnReferenceNode(tableType.Columns[0].Name, tableType.Columns[0].DataType, 0) ); #endif } else { _equalNode = Compiler.EmitBinaryNode(plan, new StackReferenceNode(Nodes[0].DataType, 1, true), Instructions.Equal, new StackReferenceNode(((Schema.TableType)Nodes[1].DataType).RowType, 0, true)); } }
protected override void InternalOpen() { _sourceTables = new Stack(Program.Stack.MaxStackDepth, Program.Stack.MaxCallDepth); _sourceTables.PushWindow(0); _parentRows = new Stack(Program.Stack.MaxStackDepth, Program.Stack.MaxCallDepth); _parentRows.PushWindow(0); PushSourceTable(null); _sourceRow = new Row(Manager, ((TableNode)Node.Nodes[0]).DataType.RowType); _tableType = new Schema.TableType(); _tableVar = new Schema.BaseTableVar(_tableType, Program.TempDevice); Schema.TableVarColumn newColumn; foreach (Schema.TableVarColumn column in Node.TableVar.Columns) { newColumn = (Schema.TableVarColumn)column.Copy(); _tableType.Columns.Add(newColumn.Column); _tableVar.Columns.Add(newColumn); } if (Node.SequenceColumnIndex < 0) { newColumn = new Schema.TableVarColumn(new Schema.Column(Keywords.Sequence, Program.DataTypes.SystemInteger), Schema.TableVarColumnType.Stored); _tableType.Columns.Add(newColumn.Column); _tableVar.Columns.Add(newColumn); _sequenceColumnIndex = _tableVar.Columns.Count - 1; } else { _sequenceColumnIndex = Node.SequenceColumnIndex; } _targetRow = new Row(Manager, _tableType.RowType); Schema.Key key = new Schema.Key(); key.Columns.Add(_tableVar.Columns[_sequenceColumnIndex]); _tableVar.Keys.Add(key); _buffer = new NativeTable(Manager, _tableVar); _scan = new Scan(Manager, _buffer, _buffer.ClusteredIndex, ScanDirection.Forward, null, null); _scan.Open(); _sequence = 0; _empty = false; InternalNext(); _empty = _scan.EOF(); _scan.First(); }
public override void DetermineDataType(Plan plan) { DetermineModifiers(plan); Nodes[0] = Compiler.EmitOrderNode(plan, SourceNode, new Schema.Order(_quotaOrder), true); _dataType = new Schema.TableType(); _tableVar = new Schema.ResultTableVar(this); _tableVar.Owner = plan.User; _tableVar.InheritMetaData(SourceTableVar.MetaData); CopyTableVarColumns(SourceTableVar.Columns); DetermineRemotable(plan); bool quotaOrderIncludesKey = false; foreach (Schema.Key key in SourceNode.TableVar.Keys) { if (Compiler.OrderIncludesKey(plan, _quotaOrder, key)) { quotaOrderIncludesKey = true; break; } } if (quotaOrderIncludesKey) { if ((Nodes[1].IsLiteral) && ((int)plan.EvaluateLiteralArgument(Nodes[1], "quota") == 1)) { Schema.Key key = new Schema.Key(); key.IsInherited = true; TableVar.Keys.Add(key); } else { CopyKeys(SourceTableVar.Keys); } } else { CopyKeys(SourceTableVar.Keys); } CopyOrders(SourceTableVar.Orders); if (SourceNode.Order != null) { Order = CopyOrder(SourceNode.Order); } #if UseReferenceDerivation #if UseElaborable if (plan.CursorContext.CursorCapabilities.HasFlag(CursorCapability.Elaborable)) #endif CopyReferences(plan, SourceTableVar); #endif plan.EnterRowContext(); try { #if USENAMEDROWVARIABLES _quotaRowType = new Schema.RowType(_quotaOrder.Columns); plan.Symbols.Push(new Symbol(Keywords.Left, _quotaRowType)); #else Schema.IRowType leftRowType = new Schema.RowType(FQuotaOrder.Columns, Keywords.Left); APlan.Symbols.Push(new Symbol(String.Empty, leftRowType)); #endif try { #if USENAMEDROWVARIABLES plan.Symbols.Push(new Symbol(Keywords.Right, _quotaRowType)); #else Schema.IRowType rightRowType = new Schema.RowType(FQuotaOrder.Columns, Keywords.Right); APlan.Symbols.Push(new Symbol(String.Empty, rightRowType)); #endif try { _equalNode = #if USENAMEDROWVARIABLES Compiler.CompileExpression(plan, Compiler.BuildRowEqualExpression(plan, Keywords.Left, Keywords.Right, _quotaRowType.Columns, _quotaRowType.Columns)); #else Compiler.CompileExpression(APlan, Compiler.BuildRowEqualExpression(APlan, leftRowType.Columns, rightRowType.Columns)); #endif } finally { plan.Symbols.Pop(); } } finally { plan.Symbols.Pop(); } } finally { plan.ExitRowContext(); } }
public override void DetermineDataType(Plan plan) { DetermineModifiers(plan); _dataType = new Schema.TableType(); _tableVar = new Schema.ResultTableVar(this); _tableVar.Owner = plan.User; _tableVar.InheritMetaData(SourceTableVar.MetaData); _tableVar.MergeMetaData(MetaData); AlterNode.AlterMetaData(_tableVar, AlterMetaData, true); CopyTableVarColumns(SourceTableVar.Columns); int sourceColumnIndex; Schema.TableVarColumn sourceColumn; Schema.TableVarColumn newColumn; _isRestrict = false; PlanNode restrictNode = null; PlanNode constraintNode; foreach (AdornColumnExpression expression in _expressions) { sourceColumnIndex = TableVar.Columns.IndexOf(expression.ColumnName); sourceColumn = TableVar.Columns[expression.ColumnName]; newColumn = CopyTableVarColumn(sourceColumn); if (expression.ChangeNilable) { newColumn.IsNilable = expression.IsNilable; } newColumn.MergeMetaData(expression.MetaData); AlterNode.AlterMetaData(newColumn, expression.AlterMetaData, true); newColumn.ReadOnly = Convert.ToBoolean(MetaData.GetTag(newColumn.MetaData, "Frontend.ReadOnly", newColumn.ReadOnly.ToString())); foreach (ConstraintDefinition constraint in expression.Constraints) { _isRestrict = true; Schema.TableVarColumnConstraint newConstraint = Compiler.CompileTableVarColumnConstraint(plan, TableVar, newColumn, constraint); //Schema.TableVarColumnConstraint newConstraint = new Schema.TableVarColumnConstraint(Schema.Object.GetObjectID(constraint.MetaData), constraint.ConstraintName); //newConstraint.ConstraintType = Schema.ConstraintType.Column; //newConstraint.MergeMetaData(constraint.MetaData); plan.PushCreationObject(newConstraint); try { plan.Symbols.Push(new Symbol(Keywords.Value, newColumn.DataType)); try { //PlanNode node = Compiler.CompileBooleanExpression(plan, constraint.Expression); //newConstraint.Node = node; //newConstraint.IsRemotable = true; //if (newConstraint.HasDependencies()) // for (int index = 0; index < newConstraint.Dependencies.Count; index++) // { // Schema.Object objectValue = newConstraint.Dependencies.Objects[index]; // if (objectValue != null) // { // if (!objectValue.IsRemotable) // { // newConstraint.IsRemotable = false; // break; // } // } // else // { // Error.Fail("Missing object dependency in AdornNode."); // //Schema.ObjectHeader LHeader = APlan.CatalogDeviceSession.SelectObjectHeader(LNewConstraint.Dependencies.IDs[LIndex]); // //if (!LHeader.IsRemotable) // //{ // // LNewConstraint.IsRemotable = false; // // break; // //} // } // } newColumn.Constraints.Add(newConstraint); constraintNode = Compiler.CompileBooleanExpression(plan, constraint.Expression); constraintNode = ReplaceColumnReferences(plan, constraintNode, sourceColumn.Name, sourceColumnIndex); if (restrictNode == null) { restrictNode = constraintNode; } else { restrictNode = Compiler.EmitBinaryNode(plan, restrictNode, Instructions.And, constraintNode); } } finally { plan.Symbols.Pop(); } } finally { plan.PopCreationObject(); } if (newConstraint.HasDependencies()) { plan.AttachDependencies(newConstraint.Dependencies); } } // TODO: verify that the default satisfies the constraints if (expression.Default != null) { newColumn.Default = Compiler.CompileTableVarColumnDefault(plan, _tableVar, newColumn, expression.Default); if (newColumn.Default.HasDependencies()) { plan.AttachDependencies(newColumn.Default.Dependencies); } } if (expression.MetaData != null) { Tag tag; tag = expression.MetaData.Tags.GetTag("DAE.IsDefaultRemotable"); if (tag != Tag.None) { newColumn.IsDefaultRemotable = newColumn.IsDefaultRemotable && Convert.ToBoolean(tag.Value); } tag = expression.MetaData.Tags.GetTag("DAE.IsChangeRemotable"); if (tag != Tag.None) { newColumn.IsChangeRemotable = newColumn.IsChangeRemotable && Convert.ToBoolean(tag.Value); } tag = expression.MetaData.Tags.GetTag("DAE.IsValidateRemotable"); if (tag != Tag.None) { newColumn.IsValidateRemotable = newColumn.IsValidateRemotable && Convert.ToBoolean(tag.Value); } } DataType.Columns[sourceColumnIndex] = newColumn.Column; TableVar.Columns[sourceColumnIndex] = newColumn; } // Keys CopyKeys(SourceTableVar.Keys); foreach (DropKeyDefinition keyDefinition in _dropKeys) { Schema.Key oldKey = Compiler.FindKey(plan, TableVar, keyDefinition); TableVar.Keys.SafeRemove(oldKey); TableVar.Constraints.SafeRemove(oldKey.Constraint); TableVar.InsertConstraints.SafeRemove(oldKey.Constraint); TableVar.UpdateConstraints.SafeRemove(oldKey.Constraint); } foreach (AlterKeyDefinition keyDefinition in _alterKeys) { Schema.Key oldKey = Compiler.FindKey(plan, TableVar, keyDefinition); AlterNode.AlterMetaData(oldKey, keyDefinition.AlterMetaData); } Compiler.CompileTableVarKeys(plan, _tableVar, _keys, false); // Orders CopyOrders(SourceTableVar.Orders); foreach (DropOrderDefinition orderDefinition in _dropOrders) { Schema.Order oldOrder = Compiler.FindOrder(plan, TableVar, orderDefinition); TableVar.Orders.SafeRemove(oldOrder); } foreach (AlterOrderDefinition orderDefinition in _alterOrders) { AlterNode.AlterMetaData(Compiler.FindOrder(plan, TableVar, orderDefinition), orderDefinition.AlterMetaData); } Compiler.CompileTableVarOrders(plan, _tableVar, _orders); if (SourceNode.Order != null) { Order = CopyOrder(SourceNode.Order); } // Constraints Compiler.CompileTableVarConstraints(plan, _tableVar, _constraints); if (_tableVar.HasConstraints()) { foreach (Schema.TableVarConstraint constraint in _tableVar.Constraints) { if (restrictNode == null) { if (constraint is Schema.RowConstraint) { restrictNode = ((Schema.RowConstraint)constraint).Node; _isRestrict = true; } } else { if (constraint is Schema.RowConstraint) { restrictNode = Compiler.EmitBinaryNode(plan, restrictNode, Instructions.And, ((Schema.RowConstraint)constraint).Node); _isRestrict = true; } } if (constraint.HasDependencies()) { plan.AttachDependencies(constraint.Dependencies); } } } if (_isRestrict) { Nodes[0] = Compiler.EmitRestrictNode(plan, Nodes[0], restrictNode); } DetermineRemotable(plan); if (MetaData != null) { Tag tag; Schema.ResultTableVar tableVar = (Schema.ResultTableVar)TableVar; tag = MetaData.Tags.GetTag("DAE.IsDefaultRemotable"); if (tag != Tag.None) { tableVar.InferredIsDefaultRemotable = tableVar.InferredIsDefaultRemotable && Convert.ToBoolean(tag.Value); } tag = MetaData.Tags.GetTag("DAE.IsChangeRemotable"); if (tag != Tag.None) { tableVar.InferredIsChangeRemotable = tableVar.InferredIsChangeRemotable && Convert.ToBoolean(tag.Value); } tag = MetaData.Tags.GetTag("DAE.IsValidateRemotable"); if (tag != Tag.None) { tableVar.InferredIsValidateRemotable = tableVar.InferredIsValidateRemotable && Convert.ToBoolean(tag.Value); } } if (Order == null) { string orderName = MetaData.GetTag(MetaData, "DAE.DefaultOrder", String.Empty); if (orderName != String.Empty) { Order = Compiler.CompileOrderDefinition ( plan, TableVar, new Parser().ParseOrderDefinition ( MetaData.GetTag ( MetaData, "DAE.DefaultOrder", String.Empty ) ), false ); } } if ((Order != null) && !TableVar.Orders.Contains(Order)) { TableVar.Orders.Add(Order); } #if UseReferenceDerivation #if UseElaborable if (plan.CursorContext.CursorCapabilities.HasFlag(CursorCapability.Elaborable)) #endif CopyReferences(plan, SourceTableVar); #endif foreach (ReferenceDefinition referenceDefinition in _references) { // Create a reference on the table var Schema.Reference reference = new Schema.Reference(Schema.Object.GetObjectID(referenceDefinition.MetaData), referenceDefinition.ReferenceName, referenceDefinition.MetaData); reference.Enforced = false; reference.SourceTable = TableVar; foreach (ReferenceColumnDefinition column in referenceDefinition.Columns) { reference.SourceKey.Columns.Add(reference.SourceTable.Columns[column.ColumnName]); } foreach (Schema.Key key in reference.SourceTable.Keys) { if (reference.SourceKey.Columns.IsSupersetOf(key.Columns)) { reference.SourceKey.IsUnique = true; break; } } Schema.Object schemaObject = Compiler.ResolveCatalogIdentifier(plan, referenceDefinition.ReferencesDefinition.TableVarName, true); if (!(schemaObject is Schema.TableVar)) { throw new CompilerException(CompilerException.Codes.InvalidReferenceObject, referenceDefinition, referenceDefinition.ReferenceName, referenceDefinition.ReferencesDefinition.TableVarName); } if (schemaObject.IsATObject) { referenceDefinition.ReferencesDefinition.TableVarName = Schema.Object.EnsureRooted(((Schema.TableVar)schemaObject).SourceTableName); } else { referenceDefinition.ReferencesDefinition.TableVarName = Schema.Object.EnsureRooted(schemaObject.Name); // Set the TableVarName in the references expression to the resolved identifier so that subsequent compiles do not depend on current library context (This really only matters in remote contexts, but there it is imperative, or this could be an ambiguous identifier) } plan.AttachDependency(schemaObject); reference.TargetTable = (Schema.TableVar)schemaObject; reference.AddDependency(schemaObject); foreach (ReferenceColumnDefinition column in referenceDefinition.ReferencesDefinition.Columns) { reference.TargetKey.Columns.Add(reference.TargetTable.Columns[column.ColumnName]); } foreach (Schema.Key key in reference.TargetTable.Keys) { if (reference.TargetKey.Columns.IsSupersetOf(key.Columns)) { reference.TargetKey.IsUnique = true; break; } } if (!reference.TargetKey.IsUnique) { throw new CompilerException(CompilerException.Codes.ReferenceMustTargetKey, referenceDefinition, referenceDefinition.ReferenceName, referenceDefinition.ReferencesDefinition.TableVarName); } if (reference.SourceKey.Columns.Count != reference.TargetKey.Columns.Count) { throw new CompilerException(CompilerException.Codes.InvalidReferenceColumnCount, referenceDefinition, referenceDefinition.ReferenceName); } TableVar.References.Add(reference); } if (!plan.IsEngine) { foreach (AlterReferenceDefinition alterReference in _alterReferences) { int referenceIndex = TableVar.References.IndexOf(alterReference.ReferenceName); if (referenceIndex < 0) { referenceIndex = TableVar.References.IndexOfOriginatingReference(alterReference.ReferenceName); } if ( (referenceIndex >= 0) || ( (plan.ApplicationTransactionID == Guid.Empty) && (!plan.InLoadingContext()) && !plan.InATCreationContext // We will be in an A/T creation context if we are reinfering view references for an A/T view ) ) { Schema.ReferenceBase referenceToAlter; if (referenceIndex < 0) { referenceToAlter = TableVar.References[alterReference.ReferenceName]; // This is just to throw the object not found error } else { referenceToAlter = TableVar.References[referenceIndex]; } AlterNode.AlterMetaData(referenceToAlter, alterReference.AlterMetaData); Schema.Object originatingReference = Compiler.ResolveCatalogIdentifier(plan, referenceToAlter.OriginatingReferenceName(), false); if (originatingReference != null) { plan.AttachDependency(originatingReference); } } } } foreach (DropReferenceDefinition dropReference in _dropReferences) { //if (TableVar.HasDerivedReferences()) //{ // int referenceIndex = TableVar.DerivedReferences.IndexOf(dropReference.ReferenceName); // if (referenceIndex >= 0) // TableVar.DerivedReferences.RemoveAt(referenceIndex); // referenceIndex = TableVar.DerivedReferences.IndexOfOriginatingReference(dropReference.ReferenceName); // if (referenceIndex >= 0) // TableVar.DerivedReferences.RemoveAt(referenceIndex); //} //if (TableVar.HasSourceReferences()) //{ // int referenceIndex = TableVar.SourceReferences.IndexOf(dropReference.ReferenceName); // if (referenceIndex >= 0) // TableVar.SourceReferences.RemoveAt(referenceIndex); // referenceIndex = TableVar.SourceReferences.IndexOfOriginatingReference(dropReference.ReferenceName); // if (referenceIndex >= 0) // TableVar.SourceReferences.RemoveAt(referenceIndex); //} //if (TableVar.HasTargetReferences()) //{ // int referenceIndex = TableVar.TargetReferences.IndexOf(dropReference.ReferenceName); // if (referenceIndex >= 0) // TableVar.TargetReferences.RemoveAt(referenceIndex); // referenceIndex = TableVar.TargetReferences.IndexOfOriginatingReference(dropReference.ReferenceName); // if (referenceIndex >= 0) // TableVar.TargetReferences.RemoveAt(referenceIndex); //} if (TableVar.HasReferences()) { int referenceIndex = TableVar.References.IndexOf(dropReference.ReferenceName); if (referenceIndex >= 0) { TableVar.References.RemoveAt(referenceIndex); } referenceIndex = TableVar.References.IndexOfOriginatingReference(dropReference.ReferenceName); if (referenceIndex >= 0) { TableVar.References.RemoveAt(referenceIndex); } } } }