Пример #1
0
        /// <summary>
        /// Create a clone of the current DmTable
        /// </summary>
        public DmTable Clone()
        {
            DmTable clone = new DmTable();

            // Set All properties
            clone.TableName              = tableName;
            clone.Schema                 = schema;
            clone.Culture                = culture;
            clone.CaseSensitive          = caseSensitive;
            clone.OriginalProvider       = OriginalProvider;
            clone.SyncDirection          = SyncDirection;
            clone.TrackingTablesPrefix   = TrackingTablesPrefix;
            clone.TrackingTablesSuffix   = TrackingTablesSuffix;
            clone.StoredProceduresPrefix = StoredProceduresPrefix;
            clone.StoredProceduresSuffix = StoredProceduresSuffix;
            clone.TriggersPrefix         = TriggersPrefix;
            clone.TriggersSuffix         = TriggersSuffix;

            // add all columns
            var clmns = this.Columns;

            for (int i = 0; i < clmns.Count; i++)
            {
                clone.Columns.Add(clmns[i].Clone());
            }

            // Create PrimaryKey
            DmColumn[] pkey = PrimaryKey.Columns;
            if (pkey != null && pkey.Length > 0)
            {
                DmColumn[] key = new DmColumn[pkey.Length];

                for (int i = 0; i < pkey.Length; i++)
                {
                    key[i] = clone.Columns[pkey[i].Ordinal];
                }

                clone.PrimaryKey = new DmKey(key);
            }

            return(clone);
        }
Пример #2
0
        /// <summary>
        /// Copy a record, whatever the state (Added, Modified, Deleted etc...)
        /// </summary>
        internal void CopyRecords(DmTable src, int srcRecord, int newRecord)
        {
            // Parcours de toutes les colonnes de destination
            for (int i = 0; i < this.Columns.Count; ++i)
            {
                // colonne de destination
                DmColumn dstColumn = this.Columns[i];
                // colonne à copier
                DmColumn srcColumn = src.Columns.FirstOrDefault(c => this.IsEqual(c.ColumnName, dstColumn.ColumnName));

                if (srcColumn == null)
                {
                    dstColumn.Init(newRecord);
                    continue;
                }

                if (dstColumn.IsValueType)
                {
                    dstColumn[newRecord] = srcColumn[srcRecord];
                    continue;
                }

                if (dstColumn.DataType == typeof(byte[]))
                {
                    byte[] srcArray  = (byte[])srcColumn[srcRecord];
                    byte[] destArray = (byte[])dstColumn[newRecord];

                    Buffer.BlockCopy(srcArray, 0, destArray, 0, srcArray.Length);
                    continue;
                }
                if (dstColumn.DataType == typeof(char[]))
                {
                    char[] srcArray  = (char[])srcColumn[srcRecord];
                    char[] destArray = (char[])dstColumn[newRecord];

                    Buffer.BlockCopy(srcArray, 0, destArray, 0, srcArray.Length);
                    continue;
                }

                dstColumn[newRecord] = srcColumn[srcRecord];
            }
        }
Пример #3
0
        /// <summary>
        /// Gets or sets the data stored in the column
        /// </summary>
        public object this[DmColumn column]
        {
            get
            {
                CheckColumn(column);
                int record = GetRecordId();
                return(column[record]);
            }
            set
            {
                CheckColumn(column);

                if (RowId != -1 && column.ReadOnly)
                {
                    throw new Exception($"ReadOnly {column.ColumnName}");
                }

                if (value == null && !column.AllowDBNull)
                {
                    throw new Exception($"Cannot set null to this {column}");
                }

                // we are going to change a value, so try to enter begin edit
                bool immediate = BeginEditInternal();
                try
                {
                    int record = GetProposedRecordId();
                    column[record] = value;
                }
                catch (Exception)
                {
                    throw;
                }

                if (immediate)
                {
                    EndEdit();
                }
            }
        }
Пример #4
0
        DmKey GetSrcKey(DmTable src, DmTable dst)
        {
            if (src.PrimaryKey != null)
            {
                return(src.PrimaryKey);
            }

            DmKey key = default(DmKey);

            if (dst.PrimaryKey != null)
            {
                DmColumn[] dstColumns = dst.PrimaryKey.Columns;
                DmColumn[] srcColumns = new DmColumn[dstColumns.Length];
                for (int j = 0; j < dstColumns.Length; j++)
                {
                    srcColumns[j] = src.Columns[dstColumns[j].ColumnName];
                }

                key = new DmKey(srcColumns); // DmKey will take ownership of srcColumns
            }

            return(key);
        }
Пример #5
0
        /// <summary>
        /// Fill the DmTable from a DbDataReader connected to any kind of database
        /// </summary>
        public void Fill(DbDataReader reader)
        {
            var readerFieldCount = reader.FieldCount;

            if (readerFieldCount == 0)
            {
                return;
            }

            if (this.Columns.Count == 0)
            {
                for (int i = 0; i < reader.FieldCount; i++)
                {
                    var      columnName = reader.GetName(i);
                    var      columnType = reader.GetFieldType(i);
                    DmColumn column     = DmColumn.CreateColumn(columnName, columnType);
                    this.Columns.Add(column);
                }
            }

            // Count - 2 because we can have a autoinc columns
            if (readerFieldCount < this.columns.Count - 2)
            {
                return;
            }

            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    object[] readerDataValues = new object[reader.FieldCount];

                    reader.GetValues(readerDataValues);
                    var dataRow = this.LoadDataRow(readerDataValues, true);
                }
            }
        }
Пример #6
0
        DmTable MergeSchema(DmTable table)
        {
            if (dataTable == null)
            {
                dataTable = table.Clone();

                if (dataTable.DmSet != null)
                {
                    dataTable.DmSet.Tables.Add(dataTable);
                }
            }
            else
            {
                // Do the columns
                int oldCount = dataTable.Columns.Count;
                for (int i = 0; i < table.Columns.Count; i++)
                {
                    DmColumn src  = table.Columns[i];
                    DmColumn dest = (dataTable.Columns.Contains(src.ColumnName, true)) ? dataTable.Columns[src.ColumnName] : null;

                    // If columns doesn't exist, create it
                    if (dest == null)
                    {
                        dest = src.Clone();
                        dataTable.Columns.Add(dest);
                    }
                }

                // check the PrimaryKey
                DmColumn[] targetPKey = dataTable.PrimaryKey.Columns;
                DmColumn[] tablePKey  = table.PrimaryKey.Columns;
                if (targetPKey.Length != tablePKey.Length)
                {
                    if (tablePKey.Length != 0)
                    {
                        throw new Exception("Merge Failed, keys are differents");
                    }

                    // special case when the target table does not have the PrimaryKey
                    if (targetPKey.Length == 0)
                    {
                        DmColumn[] key = new DmColumn[tablePKey.Length];
                        for (int i = 0; i < tablePKey.Length; i++)
                        {
                            key[i] = dataTable.Columns[tablePKey[i].ColumnName];
                        }

                        dataTable.PrimaryKey = new DmKey(key);
                    }
                }
                else
                {
                    // Check the keys are same
                    for (int i = 0; i < targetPKey.Length; i++)
                    {
                        if (!table.IsEqual(targetPKey[i].ColumnName, tablePKey[i].ColumnName))
                        {
                            throw new Exception("Merge Failed, keys are differents");
                        }
                    }
                }
            }

            return(dataTable);
        }
Пример #7
0
 public DmKey(DmColumn column)
 {
     this.columns = new[] { column };
 }