public ColumnItem(string text, ColumnTypes controlType, object defaultValue, string categoryName)
 {
     Text = text;
     ControlType = controlType;
     DefaultValue = defaultValue;
     CategoryName = categoryName;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Column" /> class.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="type">The type.</param>
        /// <param name="null">if set to <c>true</c> [null].</param>
        /// <param name="default">The default.</param>
        public Column(string name, ColumnTypes type, bool @null, Default @default)
        {
			Name = name;
			Type = type;
			Default = @default;
            Nullable = @null;
		}

        public static AccountSettingsColumn GetColumnByType(this AccountSettings settings, ColumnTypes columnType)
        {
#pragma warning disable 618
            return settings.Columns
                .FirstOrDefault(c => string.Compare(c.ColumnType.SystemName, columnType.ToString(), true) == 0);
#pragma warning restore 618
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="FieldDefinition"/> class.
 /// </summary>
 /// <param name="name">
 /// The name.
 /// </param>
 /// <param name="type">
 /// The type.
 /// </param>
 /// <param name="parentTable">
 /// The parent table.
 /// </param>
 /// <param name="securityGuardValue">
 /// The security guard value.
 /// </param>
 /// <param name="includeInResult">
 /// if set to <c>true</c> [include in result].
 /// </param>
 /// <param name="isFilterable">
 /// if set to <c>true</c> [is filterable].
 /// </param>
 /// <param name="nameValuesList">
 /// The name values list.
 /// </param>
 /// <param name="isRichText">
 /// if set to <c>true</c> [is rich text].
 /// </param>
 /// <param name="allowLocalizedData">
 /// The allow localized data.
 /// </param>
 public FieldDefinition(string name, ColumnTypes type, TableDefinition parentTable, string securityGuardValue, bool includeInResult = true, bool isFilterable = true, Dictionary<string, object> nameValuesList = null, bool isRichText = false, bool allowLocalizedData = false)
 {
     this.SystemName = name;
     this.ColumnType = type;
     _parentTable = parentTable;
     SecurityGuardValue = securityGuardValue;
     IncludeInResult = includeInResult;
     IsFilterable = isFilterable;
     NameValuesList = nameValuesList;
     IsRichText = isRichText;
     AllowLocalizedData = allowLocalizedData;
 }

 public static Column GetColumn(ColumnTypes columnType)
 {
     switch (columnType)
     {
         case ColumnTypes.DOWN:
             return new DownColumn();
         case ColumnTypes.UP:
             return new UpColumn();
         case ColumnTypes.FREE:
             return new FreeColumn();
         case ColumnTypes.ANNOUNCEMENT:
             return new AnnouncementColumn();
         default:
             throw new YambException("");
     }
 }

        /// <summary>
        /// Determines whether the specified question and answer types are compatible.
        /// </summary>
        /// <param name="questionType">
        /// The question type.
        /// </param>
        /// <param name="answerType">
        /// The answer type.
        /// </param>
        /// <returns>
        /// <c>true</c> if the specified types are compatible; otherwise, <c>false</c>.
        /// </returns>
        public bool AreTypesCompatible(ColumnTypes questionType, ColumnTypes answerType)
        {
            switch (answerType)
            {
                case ColumnTypes.Integer:
                    return questionType == ColumnTypes.Integer || questionType == ColumnTypes.Reference;

                case ColumnTypes.String:
                    return questionType == ColumnTypes.String || questionType == ColumnTypes.Frequency || questionType == ColumnTypes.AutoNumber || questionType == ColumnTypes.Label;
                
                case ColumnTypes.Reference:
                    return questionType == ColumnTypes.Reference || questionType == ColumnTypes.Integer;

                default:
                    return questionType == answerType;
            }
        }

        public bool EnterDiceValue(IViewTableForm frmTableDisplay, IConfirmForm frmConfirm, ColumnTypes column, LayerTypes layer, FieldTypes field)
        {
            if (_currentDiceThrow == DiceThrow.FIRST && !_turnEnded)
            {
                frmTableDisplay.DisplayMsg(Color.Red, _msg[4]);
                return false;
            }
            else
            {
                if (ValidEntering(frmConfirm, column))
                {
                    try
                    {
                        YambTable.GetInstance().InputValue(column, layer, field, _diceRoller.Dices, _currentDiceThrow);

                        if (column == ColumnTypes.ANNOUNCEMENT)
                        {
                            AnnouncementActions(frmTableDisplay, field);
                        }
                        else
                        {
                            NextTurn();
                            frmTableDisplay.EndOfTurnActions();
                        }

                        if (YambTable.GetInstance().IsTableFull())
                        {
                            frmTableDisplay.GameFinished();
                        }
                    }
                    catch (YambException)
                    {
                        frmTableDisplay.DisplayMsg(Color.Red, _msg[5]);
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// Initializes new instance of <see cref="T:Cebos.Veyron.Library.Process.Publisher.Definitions.MetricDefinition"/>.
        /// </summary>
        /// <param name="id">Metric's Id number.</param>
        /// <param name="name">The name of the metric.</param>
        /// <param name="guid">The <see cref="T:System.Guid"/> object that is used as unique identifier of the metric object.</param>
        /// <param name="summaryType">Type of the summary.</param>
        /// <param name="lockFilter">if set to <c>true</c> [lock filter].</param>
        /// <param name="snapshotFrequency">The snapshot frequency.</param>
        /// <param name="metricFieldSystemName">The system name of the field who's values used as metric measure.</param>
        /// <param name="groupFieldOneSystemName">The system name of the field by which to group values.</param>
        /// <param name="groupFieldTwoSystemName">The system name of the field by which to group values.</param>
        /// <param name="groupFieldThreeSystemName">The system name of the field by which to group values.</param>
        /// <param name="groupFieldFourSystemName">The system name of the field by which to group values.</param>
        /// <param name="filterGuid">The unique identifier of the filter that used in metric.</param>
        /// <param name="filterDefinition">The filter definition used to store overriden filter certainly filter with overriden UDP property.</param>
        /// <param name="orderByMetricField">The system name of the field by which to sort values or value groups if any defined.</param>
        /// <param name="orderByAscending">Whether to sorts values in ascending order.</param>
        /// <param name="orderByMetricFieldType">The type of the field which is used as sort criteria.</param>
        public MetricDefinition(
            int id,
            string name,
            Guid guid,
            SummaryTypes summaryType,
            bool lockFilter,
            string snapshotFrequency,
            string metricFieldSystemName,
            string groupFieldOneSystemName,
            string groupFieldTwoSystemName,
            string groupFieldThreeSystemName,
            string groupFieldFourSystemName,
            Guid filterGuid,
            string filterDefinition,
            string orderByMetricField,
            bool? orderByAscending,
            ColumnTypes orderByMetricFieldType)
        {
            Id = id;
            Name = name;
            Guid = guid;

            SummaryType = summaryType;
            LockFilter = lockFilter;
            SnapshotFrequency = snapshotFrequency;
            MetricFieldSystemName = metricFieldSystemName;
            GroupFieldOneSystemName = groupFieldOneSystemName;
            GroupFieldTwoSystemName = groupFieldTwoSystemName;
            GroupFieldThreeSystemName = groupFieldThreeSystemName;
            GroupFieldFourSystemName = groupFieldFourSystemName;
            FilterGuid = filterGuid;
            FilterDefinition = filterDefinition;

            OrderByMetricField = orderByMetricField;
            OrderByAscending = orderByAscending;
            OrderByMetricFieldType = orderByMetricFieldType;
        }

 public int GetLayerPointsByColumn(ColumnTypes column, LayerTypes layer)
 {
     return Columns[column].GetLayerPoints(layer);
 }

 protected ColumnDefinition ColDef(string name, ColumnTypes columnType, bool isPrimary)
 {
     return new ColumnDefinition() { Name = name, Type = columnType, IsPrimary = isPrimary };
 }

 public PropertyAttribute(ColumnTypes columnType)
 {
     this._columnType = columnType;
 }

 protected abstract bool ExistColumn(string schema, string table, string column, ColumnTypes columnType);

 public int GetLayerPointsByColumn(ColumnTypes column, LayerTypes layer)
 {
     switch (column)
     {
         case ColumnTypes.DOWN:
             return DownColumn.GetLayerPoints(layer);
         case ColumnTypes.UP:
             return UpColumn.GetLayerPoints(layer);
         case ColumnTypes.FREE:
             return FreeColumn.GetLayerPoints(layer);
         case ColumnTypes.ANNOUNCEMENT:
             return AnnouncementColumn.GetLayerPoints(layer);
         default:
             throw new YambException("");
     }
 }

 private bool ValidEntering(IConfirmForm frmConfirm, ColumnTypes column)
 {
     if (_currentDiceThrow == DiceThrow.FIRST && column == ColumnTypes.ANNOUNCEMENT)
     {
         return true;
     }
     else
     {
         string msg = GetMessage(column);
         return frmConfirm.ShowMsg(msg);
     }
 }

 private static void AddField(Collection<ICrossRefFieldViewModel> collection, ColumnTypes columnType = ColumnTypes.String)
 {
     var field = Mock.Create<ICrossRefFieldViewModel>();
     Mock.Arrange(() => field.SystemName).Returns(Guid.NewGuid().ToString());
     Mock.Arrange(() => field.Model.ColumnType).Returns(columnType);
     collection.Add(field);
 }

 public override string GetColumnTypeStringSymbol(ColumnTypes type)
 {
     switch (type)
     {
         case ColumnTypes.Double:
             return "DOUBLE";
         case ColumnTypes.Integer11:
             return "INT(11)";
         case ColumnTypes.Integer30:
             return "INT(30)";
         case ColumnTypes.UInteger11:
             return "INT(11) UNSIGNED";
         case ColumnTypes.UInteger30:
             return "INT(30) UNSIGNED";
         case ColumnTypes.Char40:
             return "CHAR(40)";
         case ColumnTypes.Char39:
             return "CHAR(39)";
         case ColumnTypes.Char38:
             return "CHAR(38)";
         case ColumnTypes.Char37:
             return "CHAR(37)";
         case ColumnTypes.Char36:
             return "CHAR(36)";
         case ColumnTypes.Char35:
             return "CHAR(35)";
         case ColumnTypes.Char34:
             return "CHAR(34)";
         case ColumnTypes.Char33:
             return "CHAR(33)";
         case ColumnTypes.Char32:
             return "CHAR(32)";
         case ColumnTypes.Char5:
             return "CHAR(5)";
         case ColumnTypes.Char1:
             return "CHAR(1)";
         case ColumnTypes.Char2:
             return "CHAR(2)";
         case ColumnTypes.String:
             return "TEXT";
         case ColumnTypes.String10:
             return "VARCHAR(10)";
         case ColumnTypes.String16:
             return "VARCHAR(16)";
         case ColumnTypes.String30:
             return "VARCHAR(30)";
         case ColumnTypes.String32:
             return "VARCHAR(32)";
         case ColumnTypes.String36:
             return "VARCHAR(36)";
         case ColumnTypes.String45:
             return "VARCHAR(45)";
         case ColumnTypes.String50:
             return "VARCHAR(50)";
         case ColumnTypes.String64:
             return "VARCHAR(64)";
         case ColumnTypes.String128:
             return "VARCHAR(128)";
         case ColumnTypes.String100:
             return "VARCHAR(100)";
         case ColumnTypes.String255:
             return "VARCHAR(255)";
         case ColumnTypes.String512:
             return "VARCHAR(512)";
         case ColumnTypes.String1024:
             return "VARCHAR(1024)";
         case ColumnTypes.String8196:
             return "VARCHAR(8196)";
         case ColumnTypes.Text:
             return "TEXT";
         case ColumnTypes.MediumText:
             return "MEDIUMTEXT";
         case ColumnTypes.LongText:
             return "LONGTEXT";
         case ColumnTypes.Blob:
             return "BLOB";
         case ColumnTypes.LongBlob:
             return "LONGBLOB";
         case ColumnTypes.Date:
             return "DATE";
         case ColumnTypes.DateTime:
             return "DATETIME";
         case ColumnTypes.Float:
             return "FLOAT";
         case ColumnTypes.TinyInt1:
             return "TINYINT(1)";
         case ColumnTypes.TinyInt4:
             return "TINYINT(4)";
         case ColumnTypes.UTinyInt4:
             return "TINYINT(4) UNSIGNED";
         case ColumnTypes.Binary32:
             return "BINARY(32)";
         case ColumnTypes.Binary64:
             return "BINARY(64)";
         default:
             throw new DataManagerException("Unknown column type.");
     }
 }

 public static AccountSettingsColumn GetColumnFor(this AccountSettings settings, ColumnTypes type)
 {
     return settings.Columns.FirstOrDefault(c => c.ColumnType.Type == type);
 }

 public abstract string GetColumnTypeStringSymbol(ColumnTypes type);

        public bool ExistColumn(string schema, string table, string column, ColumnTypes columnType)
        {
            using (var connection = new SQLiteConnection(this.ConnectionString))
            {
                connection.Open();
                using (var command = connection.CreateCommand())
                {
                    var cmdText = @"
            pragma table_info(" + table + ")";

                    command.CommandText = cmdText;
                    using (var reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            var name = ((string)reader["name"]).Trim().ToLowerInvariant();
                            var type = ((string)reader["type"]).Trim().ToLowerInvariant();

                            if (name.Equals(column.Trim().ToLowerInvariant()))
                            {
                                switch (columnType)
                                {
                                    case ColumnTypes.ObjectId:
                                        return "integer".Equals(type);
                                    case ColumnTypes.TypeId:
                                        return "blob".Equals(type);
                                    case ColumnTypes.CacheId:
                                        return "integer".Equals(type);
                                    case ColumnTypes.Binary:
                                        return "blob".Equals(type);
                                    case ColumnTypes.Boolean:
                                        return "integer".Equals(type);
                                    case ColumnTypes.Decimal:
                                        return "text".Equals(type);
                                    case ColumnTypes.Float:
                                        return "real".Equals(type);
                                    case ColumnTypes.Integer:
                                        return "integer".Equals(type);
                                    case ColumnTypes.String:
                                        return "text".Equals(type);
                                    case ColumnTypes.Unique:
                                        return "text".Equals(type);
                                }

                                return true;
                            }
                        }
                    }

                    return false;
                }
            }
        }

 protected abstract bool Match(ColumnTypes columnType, string dataType);