/// <summary> /// Determines whether two specified values are equal. /// </summary> /// <param name="tableA">The first value to compare.</param> /// <param name="tableB">The second value to compare.</param> internal bool Equals(DB3 tableA, DB3 tableB) { return ((TableA.Equals(tableA) && TableB.Equals(tableB)) || (TableA.Equals(tableB) && TableB.Equals(tableA))); }
internal static ColumnMap GetColumnMap(DB3 columnID) { var tableMap = GetNodeMap(columnID.TableID); return(tableMap.Columns.Where(a => a.ID.Equals(columnID)) .Single()); }
/// <summary> /// Initializes a new instance of the DatabaseMap class. /// </summary> /// <param name="name"></param> /// <param name="mappingDate"></param> /// <param name="isWhole"></param> public DatabaseMap(Identifier name, DateTime mappingDate, bool isWhole) : base(DB3.Get(DbMapping.NewDatabaseID)) { Name = name; MappingDate = mappingDate; IsWhole = isWhole; }
internal static DataParamChainer AddNodeColumns(Chainer prev, DB3 nodeID, ColumnSelector selector, string prefix) { var node = DbMapping.GetNodeMap(nodeID); ColumnMap[] columns; if (selector == ColumnSelector.All) { if (node.HasRowversion) { return(((IParam)prev).Param(prefix.AsParam(1), node.RowversionColumn.DataType)); } columns = node.SortedColumns; } else if (selector == ColumnSelector.RK) { columns = node.SortedRKColumns; } else if (selector == ColumnSelector.InsertableWithIdentity) { columns = node.GetInsertableColumns(true); } else { columns = node.GetInsertableColumns(false); } return(AddNodeColumns(prev, columns, prefix)); }
internal Relation AddGraphPair(DB3 foreignKey, DbNode predecessorNode, DbNode relatedNode, Link link) { SetRX(relatedNode); // We need to replace foreignKey with the invoker's one. // attention: // This is needed because the default foreign key is the first column. Since it is allowed // that any column represents the foreign key, the user's foreign key must be replaced with // the default one in order to fit the graph invoker's default foreign key. DB3 invokerForeignKey; GraphPair pair; Relation relation; if (link.IsFKTable(predecessorNode.NodeID)) // => predecessor node is FK, related node is REFERENCE { invokerForeignKey = _GetInvokerForeignKey(link, foreignKey, out relation); pair = new GraphPair(invokerForeignKey, relatedNode.NodeID, predecessorNode.RX, relatedNode.RX); } else { invokerForeignKey = _GetInvokerForeignKey(link, foreignKey, out relation); pair = new GraphPair(invokerForeignKey, predecessorNode.NodeID, relatedNode.RX, predecessorNode.RX); } _graphPairs.Add(pair); return(relation); }
/// <summary> /// Determines whether the specified argument is equal to this instance. /// </summary> /// <param name="other">The argument to compare with this instance.</param> public bool Equals(DB3 other) { if (other.DbX == _dbX && other.TableY == _tableY && other.ColumnZ == _columnZ) { return(true); } return(false); }
/// <summary> /// Initializes a new instance of the NodeMap class. /// </summary> /// <param name="id">A DB3 identifier of a database object.</param> /// <param name="name">A name of a database object.</param> /// <param name="hasGenuineRK">A flag to indicate whether a database object has a genuine row key (PK or UK).</param> public NodeMap(DB3 id, Identifier name, bool hasGenuineRK = true) : base(id) { Name = name; Columns = new HashSet <ColumnMap>(new MapEqualityComparer()); Params = new HashSet <ParamMap>(new MapEqualityComparer()); HasGenuineRK = hasGenuineRK; }
internal bool IsInnerJoin(DB3 firstTable) { if (IsRefTable(firstTable)) { return(true); } return(!DbMapping.GetColumnMap(FKColumns[0]).IsNullable); }
internal static void ThrowForeignKeyNotFoundException(DB3 foreignKey, DB3 table) { var foreignKeyFullName = DbMapping.GetForeignKeyName(foreignKey); throw new QueryTalkException("Link.TryGetRelation", QueryTalkExceptionType.ForeignKeyNotFound, String.Format("table = {0}{1} foreign key = {2}", DbMapping.GetNodeMap(table).Name.Sql, Environment.NewLine, foreignKeyFullName), Text.Method.By); }
private static Procedure ReloadProc(DB3 nodeID, ColumnSelector selector) { return(Designer.GetNewDesigner(Text.Method.ReloadGo, true, true) .ParamNodeColumns(nodeID, selector) .Param("@Table", Designer.Inliner.Table) .Param("@Where", Designer.Inliner.Expression) .From("@Table") .Where("@Where") .Select() .EndProc()); }
// invoke a specified node's static ctor private static void _Invoke(DB3 nodeID) { var invoker = _invokers.Where(a => a.ID.Equals(nodeID)).FirstOrDefault(); if (invoker == null) { ThrowNodeNotFoundException(nodeID); } invoker.Invoke(); }
/// <summary> /// Initializes a new instance of the NodeTree class. /// </summary> /// <param name="parent">Is a DB3 identifier of a parent.</param> /// <param name="child">Is a DB3 identifier of a child.</param> /// <param name="level">A tree level.</param> /// <param name="maxLevels">level should not exceed maxLevels.</param> public NodeTree(DB3 parent, DB3 child, int level, int maxLevels) { if (maxLevels <= level) { throw new QueryTalkException("NodeTree.ctor", QueryTalkExceptionType.MaxLevelsExceeded, String.Format("maxLevels = {0}", maxLevels), Text.Method.DeleteCascadeGo); } Parent = parent; Child = child; Level = level; }
internal static string GetForeignKeyName(DB3 foreignKey) { ColumnMap foreignKeyMap; string foreignKeyFullName = Text.Unknown; if (!foreignKey.Equals(DB3.Default)) { foreignKeyMap = GetColumnMap(foreignKey); foreignKeyFullName = foreignKeyMap.FullName; } return(foreignKeyFullName); }
private static Procedure DeleteProc(DB3 nodeID, ColumnSelector selector) { return(Designer.GetNewDesigner(Text.Method.DeleteGo, true, true) .ParamNodeColumns(nodeID, selector) .Param("@Table", Designer.Inliner.Table) .Param("@Where", Designer.Inliner.Expression) .From("@Table") .Where("@Where") .Delete() .Declare <int>("@r").Set(Designer.RowCount) .Return("@r") .EndProc()); }
// invoke certain graph creator internal static void GraphInvoke(DB3 foreignkeyID, DB3 referenceID, IEnumerable foreignKeyTable, IEnumerable referenceTable) { var invoker = _graphInvokers.Where(a => a.ForeignKeyID.Equals(foreignkeyID) && a.ReferenceID.Equals(referenceID)).FirstOrDefault(); if (invoker != null) { invoker.Invoke(foreignKeyTable, referenceTable); } else { throw new QueryTalkException("DbMapping.GraphInvoke", QueryTalkExceptionType.InvokerNotFoundInnerException, String.Format("foreignKeyID = {0}{1} referenceID = {2}", foreignkeyID, Environment.NewLine, referenceID)); } }
private static void ThrowNodeNotFoundException(DB3 nodeID) { // try get database var database = _databases.Where(a => a.ID == nodeID.DatabaseID).FirstOrDefault(); if (database != null) { throw new QueryTalkException("DbMapping.GetNodeMap", QueryTalkExceptionType.NodeNotFoundInnerException, String.Format("database = {0}{1} requested node ID = {2}", database.Name, Environment.NewLine, nodeID)); } else { throw new QueryTalkException("DbMapping.GetNodeMap", QueryTalkExceptionType.NodeNotFoundInnerException, String.Format("requested node ID = {0}", nodeID)); } }
internal Relation TryGetRelation(DB3 foreignKey, string method = null) { if (HasIntermediate) { throw new QueryTalkException("Link.TryGetRelation", QueryTalkExceptionType.IntermediateTableDisallowed, String.Format("linked tables = {0}:{1}{2} intermediate table = {3}", DbMapping.GetNodeMap(TableA).Name.Sql, DbMapping.GetNodeMap(TableB).Name.Sql, Environment.NewLine, DbMapping.GetNodeMap(Intermediate).Name.Sql), method); } Relation relation = null; if (foreignKey.Equals(DB3.Default)) { // single relation if (_relations.Count == 1) { return(_relations.First()); } // many relations - missing FK else { throw new QueryTalkException("Link.TryGetRelation", QueryTalkExceptionType.MissingForeignKey, String.Format("linked tables = {0}:{1}", DbMapping.GetNodeMap(TableA).Name.Sql, DbMapping.GetNodeMap(TableB).Name.Sql), method); } } // foreign key is defined: else { relation = _relations.Where(a => a.FKColumns.Contains(foreignKey)) .FirstOrDefault(); if (relation == null) { DbMapping.ThrowForeignKeyNotFoundException(foreignKey, TableA); } } return(relation); }
internal static NodeMap GetNodeMap(DB3 nodeID) { var node = _nodes.Where(a => a.ID.Equals(nodeID)) .SingleOrDefault(); if (node == null) { _Invoke(nodeID); node = _nodes.Where(a => a.ID.Equals(nodeID)) .SingleOrDefault(); } if (node == null) { ThrowNodeNotFoundException(nodeID); } return(node); }
// builds a relation SQL clause internal static Relation GetRelation(DB3 tableA, DB3 tableB, DB3 foreignKey, string method = null) { var link = TryFindLink(tableA, tableB, method); if (foreignKey.Equals(DB3.Default)) { if (link.HasManyRelations) { throw new QueryTalkException("DbMapping.BuildRelation", QueryTalkExceptionType.MissingForeignKey, String.Format("linked tables = {0}:{1}", GetNodeMap(tableA).Name.Sql, GetNodeMap(tableB).Name.Sql), method); } else { foreignKey = link.DefaultForeignKey; } } return(link.TryGetRelation(foreignKey, method)); }
internal static Link TryFindLink(DB3 tableA, DB3 tableB, string method = null) { var link = GetLink(tableA, tableB); if (link == null && !tableA.Equals(tableB)) { link = TryFindIntermediate(tableA, tableB, method); } // second check if (link == null) { throw new QueryTalkException("DbMapping.TryFindLink", QueryTalkExceptionType.LinkNotFound, String.Format("table A = {0}{1} table B = {2}", DbMapping.GetNodeMap(tableA).Name.Sql, Environment.NewLine, DbMapping.GetNodeMap(tableB).Name.Sql), method); } return(link); }
/// <summary> /// Initializes a new instance of the ColumnMap class. /// </summary> /// <param name="id">A DB3 identifier of a column.</param> /// <param name="columnOrdinal">A column ordinal.</param> /// <param name="name">A name of a column.</param> /// <param name="dataType">A data type.</param> /// <param name="isNullable">A flag to indicate if a column is nullable.</param> /// <param name="isRK">A flag to indicate if a column is part of a row key.</param> /// <param name="isUK">A flag to indicate if a column is part of a unique key.</param> /// <param name="isFK">A flag to indicate if a column is part of a foreign key.</param> /// <param name="columnType">A column type.</param> /// <param name="hasDefault">A flag to indicate if a column has a default constraint.</param> public ColumnMap( DB3 id, int columnOrdinal, Identifier name, DataType dataType, bool isNullable, bool isRK = false, bool isUK = false, bool isFK = false, ColumnType columnType = Wall.ColumnType.Regular, bool hasDefault = false) : base(id) { ColumnOrdinal = columnOrdinal; Name = name; DataType = dataType; IsNullable = isNullable; IsRK = isRK; IsUK = isUK; IsFK = isFK; ColumnType = columnType; HasDefault = hasDefault; }
/// <summary> /// Initializes a new instance of the DbColumn class. /// </summary> /// <param name="parent">A parent.</param> /// <param name="columnID">A DB3 identifier of a column.</param> public DbColumn(DbNode parent, DB3 columnID) { _parent = parent; ColumnID = columnID; Build = (buildContext, buildArgs) => { _parent.CheckReuseAndThrow(); // note: // If the current object is a PivotChainer, then the previous FromChainer is not accessable // by the select statement any more if (buildContext.Current is PivotChainer) { return(ColumnMap.Name.Sql); } string alias = Text.Zero; if (buildContext.Current.QueryPart != null && buildContext.Current.QueryPart.Joiner != null) { alias = buildContext.Current.QueryPart.Joiner.ProcessColumn(this); } if (alias != Text.ZeroAlias) { return(String.Format("{0}.{1}", Filter.Delimit(alias), IsAllColumns ? Text.Asterisk : ColumnMap.Name.Sql)); } else { return(String.Format("{0}", IsAllColumns ? Text.Asterisk : ColumnMap.Name.Sql)); } }; }
internal string BuildRelation(DB3 table1, string alias1, string alias2) { string aliasA, aliasB; if (table1.TableID.Equals(ID.TableID) && !IsSelfRelation) { aliasA = alias1; aliasB = alias2; } else { aliasA = alias2; aliasB = alias1; } var sql = Text.GenerateSql(70); for (int i = 0; i < FKColumns.Count(); ++i) { if (i > 0) { sql.Append(Text._And_); } var columnA = DbMapping.GetColumnMap(FKColumns[i]); var columnB = DbMapping.GetColumnMap(RefColumns[i]); sql .AppendFormat("[{0}].{1} = [{2}].{3}", aliasA, columnA.Name.Sql, aliasB, columnB.Name.Sql); } return(sql.ToString()); }
/// <summary> /// Adds a row type to the mapping data. /// </summary> /// <param name="type">A type of the row.</param> /// <param name="nodeID">A node mapping identifier that row belongs to.</param> public static void AddRowType(Type type, DB3 nodeID) { DbMapping.AddRowType(type, nodeID); }
internal DbColumns(DbNode parent, DB3 columnID, string alias) { Column = new DbColumn(parent, columnID, alias); }
internal DbColumns(DbNode parent, DB3 columnID) { Column = new DbColumn(parent, columnID); }
/// <summary> /// Initializes a new instance of the Relation class. /// </summary> /// <param name="foreignKey">The specified column of the relation which represents a unique identifier of the relation between the two tables.</param> /// <param name="foreignKeyColumns">The columns which are part of the key in table A.</param> /// <param name="referenceKeyColumns">The columns which are part of the key in table B.</param> public Relation(DB3 foreignKey, DB3[] foreignKeyColumns, DB3[] referenceKeyColumns) : base(foreignKey) { FKColumns = foreignKeyColumns; RefColumns = referenceKeyColumns; }
// returns true if the table is on foreign key side in the relationship internal bool IsFKTable(DB3 table) { return(table.Equals(FKTable)); }
// returns true if the table is on reference side in the relationship internal bool IsRefTable(DB3 table) { return(table.Equals(RefTable)); }
internal string BuildRelation(DB3 table1, int alias1, int alias2) { return(BuildRelation(table1, alias1.ToString(), alias2.ToString())); }