示例#1
0
 // add a new data table to the set only if the set does not contain apropriate table yet
 private void AddTableToSet(LogicalQueryTable queryTable)
 {
     if (this.currentSet.Tables.Find((x) => x.Name.Equals(queryTable.Table.Name)) == null) {
         DataTable dataTable = ToDataTable (queryTable.Table);
         this.currentSet.Tables.Add (dataTable);
         // add table shortcut
         this.tablesShortcut.Add (queryTable, dataTable);
     }
 }
 // should throw an exception if source is not included in the tree
 public virtual LogicalQueryTable JoinTable(LogicalQueryTable source, LogicalTable joinWith)
 {
     // first check if source is the last added node, if not search the whole tree
     if (!this.logicalTables.Contains(source)) {
         throw new ArgumentException("Source table is not present in the query.");
     }
     attachTable(source, joinWith);
     return this.lastTableAdded;
 }
示例#3
0
        private LogicalQueryTable CreatePartOfEntityTable()
        {
            LogicalQueryTable queryTable = new LogicalQueryTable() {Alias = "Entity_0"};

            LogicalTable logicalTable = new LogicalTable() {Name = "EntityPart", TableType = LogicalTableType.ENTITY};
            queryTable.Table = logicalTable;

            TableDefinition physicalTable = new TableDefinition() {Name = "Entity"};

            logicalTable.PartOfTable = physicalTable;

            TableColumn nameColumn = new TableColumn() {Name="name", Table = physicalTable};

            physicalTable.addColumn(nameColumn);
            logicalTable.AddColumn(nameColumn);

            return queryTable;
        }
示例#4
0
        private LogicalQueryTable CreateSingleEntityTable()
        {
            LogicalQueryTable queryTable = new LogicalQueryTable() {Alias = "Entity_0"};

            LogicalTable logicalTable = new LogicalTable() {Name = "Entity", TableType = LogicalTableType.ENTITY};
            queryTable.Table = logicalTable;

            TableDefinition physicalTable = new TableDefinition() {Name = "Entity"};

            logicalTable.PartOfTable = physicalTable;

            TableColumn idColumn = new TableColumn() {IsPrimaryKey = true, Name="id", Table = physicalTable};
            TableColumn nameColumn = new TableColumn() {Name="name", Table = physicalTable};

            physicalTable.addColumn(idColumn);
            physicalTable.addColumn(nameColumn);

            logicalTable.AddColumn(idColumn);
            logicalTable.AddColumn(nameColumn);

            return queryTable;
        }
示例#5
0
 private DataTable GetDataTable(LogicalQueryTable queryTable)
 {
     return this.tablesShortcut[queryTable];
 }
示例#6
0
 public bool IsLogicalTableEqual(LogicalQueryTable queryTable)
 {
     return Table.IsPartOfTheSameTable(queryTable.Table);
 }
        private void attachTable(LogicalQueryTable source, LogicalTable joinWith)
        {
            // check if join can be performed, if not then exception is thrown
            validateAttachArguments(source, joinWith);

            // join tables
            LogicalQueryTable target = new LogicalQueryTable() {Table = joinWith};

            // if the join table is in fact a part of another physical table already included in source logical table
            // then dont join them
            // always join tables if the target table is of entity type
            if (!isJoinRequired (source, target)) {
                target.Alias = source.Alias;
            } else {
                string alias = createTableAlias(joinWith);
                target.Alias = alias;

                PhysicalQueryTable physicalQueryTable = new PhysicalQueryTable() {Table = joinWith.PartOfTable, Alias = alias};
                this.physicalTables.Add (physicalQueryTable);

                this.fromSource = createNewJoin (this.fromSource, source, target);
            }

            this.logicalTables.Add (target);
            this.lastTableAdded = target;
        }
 private void validateAttachArguments(LogicalQueryTable source, LogicalTable joinWith)
 {
     if (source.Table.Equals(joinWith)) {
         throw new ArgumentException("Cannot join a logical table with itself");
     } else if (source.Table.TableType.Equals (joinWith.TableType)) {
         throw new ArgumentException("Cannot join two entity logical or two join logical tables");
     }
 }
 private void setRootTable(LogicalTable rootTable)
 {
     string alias = createTableAlias(rootTable);
     LogicalQueryTable queryTable = new LogicalQueryTable() {Table = rootTable, Alias = alias};
     PhysicalQueryTable physicalQueryTable = new PhysicalQueryTable() {Table = rootTable.PartOfTable, Alias = alias};
     this.logicalTables.Add (queryTable);
     this.physicalTables.Add (physicalQueryTable);
     this.fromSource = physicalQueryTable.ToTableReference();
     this.lastTableAdded = queryTable;
 }
示例#10
0
 private bool isJoinRequired(LogicalQueryTable source, LogicalQueryTable target)
 {
     return !source.IsLogicalTableEqual(target);
 }
示例#11
0
        private ITableExpression createNewJoin(ITableExpression oldJoin, LogicalQueryTable sourceTable, LogicalQueryTable targetTable)
        {
            LogicalQueryTable relationTable = (sourceTable.Table.TableType == LogicalTableType.JOIN ? sourceTable : targetTable);
            LogicalQueryTable entityTable = (sourceTable.Table.TableType == LogicalTableType.ENTITY ? sourceTable : targetTable);

            TableColumn primaryKey = entityTable.Table.GetPrimaryKey();
            TableColumn foreignKey = relationTable.Table.GetForeignKey(primaryKey);

            ILogicalCondition on = Logical.Equal(Expression.Column(entityTable.Alias, primaryKey.Name), Expression.Column (relationTable.Alias, foreignKey.Name));

            return From.Left (oldJoin, targetTable.ToTableReference(), on);
        }