/// <summary>
/// Resets default for not nullable columns to empty string if it is null. Just to get behavior
/// more like Query Browser.
/// </summary>
/// <param name="connection">The DataConnectionWrapper to be used for enumeration.</param>
/// <param name="table">Table with data to post process.</param>>
protected override void PostProcessData(DataConnectionWrapper connection, DataTable table)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
if (table == null)
{
throw new ArgumentNullException("table");
}
// Call to base
base.PostProcessData(connection, table);
// Do not process table whithout rows
if (table.Rows == null)
{
return;
}
// Reset default value for each not nullable column to empty string if
// it is null
foreach (DataRow column in table.Rows)
{
if (DataInterpreter.GetSqlBool(column, Attributes.Nullable).IsFalse &&
!DataInterpreter.IsNotNull(column, Attributes.Default))
{
DataInterpreter.SetValueIfChanged(column, Attributes.Default, String.Empty);
}
}
}
/// <summary>
/// Fills available values for index comboboxes
/// </summary>
private void FillComboboxes()
{
// Fill index kind combobox
indexKindSelect.Tag = Index.IndexKind;
FillCombobox(indexKindSelect, Document.GetSupportedIndexKinds());
// If indexes are not supported at all, disable add button
bool enabled = indexKindSelect.Items.Count > 0;
addButton.Enabled = enabled;
// If selected index is primary key, add it to the list of available kinds and select
if (DataInterpreter.CompareInvariant(SelectedIndexName, IndexDescriptor.PRIMARY))
{
indexKindSelect.Items.Add(IndexDescriptor.PRIMARY);
indexKindSelect.SelectedItem = IndexDescriptor.PRIMARY;
}
// Fill index types
indexTypeSelect.Tag = Index.IndexType;
FillCombobox(indexTypeSelect, Document.GetSupportedIndexTypes());
// Disable combobox if only one type is supported
indexTypeSelect.Enabled = indexTypeSelect.Items.Count > 1;
}
/// <summary>
/// Creates new stored function identifier template without name part.
/// </summary>
/// <param name="hierarchy">Server explorer facade object to be used for Server Explorer hierarchy interaction.</param>
/// <param name="typeName">Object type name to create identifier.</param>
/// <returns>Returns new stored function identifier template without name part.</returns>
protected override object[] CreateNewIDBase(ServerExplorerFacade hierarchy, string typeName)
{
if (hierarchy == null)
{
throw new ArgumentNullException("hierarchy");
}
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
// Only stored procedures are supported
if (!DataInterpreter.CompareInvariant(typeName, StoredProcDescriptor.TypeName))
{
throw new NotSupportedException(String.Format(
CultureInfo.CurrentCulture,
Resources.Error_ObjectTypeNotSupported,
typeName));
}
// Get default schema
string schema = hierarchy.Connection.Schema;
Debug.Assert(!String.IsNullOrEmpty(schema), "Failed to retrive schema name!");
if (schema == null)
{
return(null);
}
return(new object[] { null, schema, null });
}
/// <summary>
/// Fills details view with data for selected foreign key.
/// </summary>
private void FillSelectedKeyView()
{
// If selected key is empty, reset view and exit
if (SelectedKey == null)
{
ResetSelectedKeyView();
return;
}
// Lock selected key updates
lockUpdate = true;
// Enable key settings
keySettingsGroup.Enabled = true;
// Fill key name
keyNameText.DataSource = SelectedKey;
// Select referenced table
refTableSelect.SelectedValue = DataInterpreter.GetStringNotNull(SelectedKey, ForeignKey.ReferencedTableName);
// Attache referenced column column to the datasource
AttachReferencedColumnColumn();
// Attach grid view to filtered datasource
AttachForeignKeyColumns();
// Select proper actions
onDeleteSelect.SelectedItem = SelectedKey[ForeignKey.OnDelete];
onUpdateSelect.SelectedItem = SelectedKey[ForeignKey.OnUpdate];
// Unlock selected key updates
lockUpdate = false;
}
/// <summary>
/// Handles referenced table changes and sets correct data source for
/// the refernced column column
/// </summary>
/// <param name="sender">Sender of the event.</param>
/// <param name="e">Detailed information about event.</param>
private void OnReferencedTableChanged(object sender, EventArgs e)
{
// If update is loked, exit
if (lockUpdate)
{
return;
}
// Reset foreign key columns
DataView view = foreigKeyColumns.DataSource as DataView;
if (view != null)
{
for (int i = view.Count - 1; i >= 0; i--)
{
view.Delete(i);
}
}
// Set new referenced table
if (SelectedKey != null)
{
DataInterpreter.SetValueIfChanged(SelectedKey, ForeignKey.ReferencedTableName, ReferencedTable);
}
AttachReferencedColumnColumn();
}
/// <summary>
/// Creates a new user defined function identifier template
/// </summary>
/// <param name="hierarchy">A server explorer facade object to interact with
/// Server Explorer hierarchy</param>
/// <param name="typeName">An object type name to create</param>
/// <returns>Returns a new user defined function identifier template</returns>
protected override object[] CreateNewIDBase(ServerExplorerFacade hierarchy, string typeName)
{
if (hierarchy == null)
{
throw new ArgumentNullException("hierarchy");
}
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
// Checking a type name
if (!DataInterpreter.CompareInvariant(typeName, UdfDescriptor.TypeName))
{
throw new NotSupportedException(
String.Format(
CultureInfo.CurrentCulture,
Resources.Error_ObjectTypeNotSupported,
typeName)
);
}
// Get a default schema
string schema = hierarchy.Connection.Schema;
if (schema == null)
{
return(null);
}
return(new object[] { null, null });
}
/// <summary>
/// Handles mouse movements and makes checkboxes hot.
/// </summary>
/// <param name="e">Makes checkboses hot.</param>
protected override void OnMouseMove(DataGridViewCellMouseEventArgs e)
{
if (this.DataGridView == null || e == null || e.RowIndex < 0 ||
e.RowIndex >= this.DataGridView.RowCount)
{
return;
}
// Get hot flag name
string hotFlag = GetHotFlagName(e.Location, e.RowIndex);
// Skip if nothing changed
if (DataInterpreter.CompareInvariant(hotItem, hotFlag))
{
base.OnMouseMove(e);
return;
}
// Store old hot item
string oldHotItem = hotItem;
// Store new hot item
hotItem = hotFlag;
// Invalidate old hot item, if any
InvalidateItem(e.ColumnIndex, e.RowIndex, oldHotItem);
// Invalidate new hot item, if any
InvalidateItem(e.ColumnIndex, e.RowIndex, hotItem);
}
/// <summary>
/// Returns CREATE DATABASE statement for given schema.
/// </summary>
/// <param name="connection">Connection to use to execute query.</param>
/// <param name="schema">DataRow with information about schema.</param>
/// <returns>Returns CREATE DATABASE statement for given schema.</returns>
private string GetCreateDatabase(DataConnectionWrapper connection, DataRow schema)
{
// Extract schema and table name
string schemaName = DataInterpreter.GetString(schema, Attributes.Schema);
if (String.IsNullOrEmpty(schemaName))
{
Debug.Fail("Unable to get schema name");
return(String.Empty);
}
// Build SHOW CREATE DATABASE
StringBuilder query = new StringBuilder();
query.Append("SHOW CREATE DATABASE ");
QueryBuilder.WriteIdentifier(schemaName, query);
// Execute query and check result table
DataTable createDatabase = connection.ExecuteSelectTable(query.ToString());
if (createDatabase == null || createDatabase.Rows.Count <= 0)
{
Debug.Fail("Failed to read CREATE TABLE query!");
return(String.Empty);
}
// Extract result
string result = DataInterpreter.GetString(createDatabase.Rows[0], "Create Database");
// Dispose table and exit
createDatabase.Dispose();
return(result);
}
/// <summary>
/// Builds supported flags list for the given column datatype.
/// </summary>
/// <param name="dataType">Column datatype.</param>
private void BuildFlags(int rowIndex)
{
DataRow column = GetColumnRow(rowIndex);
string dataType = column != null?DataInterpreter.GetStringNotNull(column, Column.MySqlType) : String.Empty;
flags.Clear();
// If numeric, add UNSIGNED and ZEROFILL
if (Parser.SupportUnsignedAndZerofill(dataType))
{
AddNumericFlags();
}
// If supports BINARY, add it
if (Parser.SupportBinary(dataType))
{
AddBinaryFlag();
}
// If supports ASCII and UNICODE, add them
if (Parser.SupportAsciiAndUnicode(dataType))
{
AddAsciiAndUnicode();
}
// Fill flags with data
FillFlags(column);
}
/// <summary>
/// Handles click on the cell content an switch checkboxes.
/// </summary>
/// <param name="e">Information on the event.</param>
protected override void OnClick(DataGridViewCellEventArgs e)
{
if (this.DataGridView == null || e == null || e.RowIndex < 0 ||
e.RowIndex >= this.DataGridView.RowCount)
{
return;
}
if (String.IsNullOrEmpty(hotItem) || !checkboxes.ContainsKey(hotItem))
{
return;
}
// Switch flag
flags[hotItem] = !flags[hotItem];
// If column row not empty, change it value
DataRow column = GetColumnRow(e.RowIndex);
if (column != null)
{
DataInterpreter.SetValueIfChanged(
column,
hotItem,
flags[hotItem] ? DataInterpreter.True : DataInterpreter.False);
}
// Notify grid about changes
NotifyDataGridViewOfValueChange();
}
/// <summary>
/// Returns DataTable with description of table's columns.
/// </summary>
/// <param name="connection">Connection object to use for queries.</param>
/// <param name="restrictions">Restrictions on table and propably on column.</param>
/// <param name="sort">Sort string to use.</param>
/// <returns>Returns DataTable with description of table's columns.</returns>
private DataTable ReadColumnsForTable(DataConnectionWrapper connection, object[] restrictions, string sort)
{
// Execute base method
DataTable result = base.ReadTable(connection, restrictions, sort);
// hackity, hack, hack. We are just doing this so we can avoid having to rewrite a ton
// of code to use a data reader to work around the server stupid binary issues.
result = ConvertTableIfNecessary(result);
// If result is null, exit
if (result == null)
{
return(null);
}
// Extract table name
string table = restrictions[2] as string;
// For legacy version rename columns
RenameColumn("Field", Attributes.Name, result);
RenameColumn("Type", Attributes.ColumnType, result);
RenameColumn("Null", Attributes.Nullable, result);
RenameColumn("Key", Attributes.ColumnKey, result);
RenameColumn("Default", Attributes.Default, result);
RenameColumn("Extra", Attributes.Extra, result);
// Calculate schema name
string schema;
if (restrictions.Length >= 2 && !String.IsNullOrEmpty(restrictions[1] as string))
{
schema = restrictions[1] as string;
}
else
{
schema = connection.Schema;
}
// Add catalog, schema and type column
result.Columns.Add(Attributes.Schema, typeof(string));
result.Columns.Add(Attributes.Table, typeof(string));
// Set schema and table name for each row
foreach (DataRow column in result.Rows)
{
DataInterpreter.SetValueIfChanged(column, Attributes.Schema, schema);
DataInterpreter.SetValueIfChanged(column, Attributes.Table, table);
// Empty value in IS_NULABLE column means NO
if (!DataInterpreter.IsNotEmptyString(column, Attributes.Nullable))
{
DataInterpreter.SetValueIfChanged(column, Attributes.Nullable, DataInterpreter.False);
}
}
// Finaly, return result
return(result);
}
/// <summary>
/// Reads table with Database Objects which satisfy given restriction. Base implementation
/// uses direct SQL query to the INFORMATION_SCHEMA.
/// </summary>
/// <param name="connection">The DataConnectionWrapper to be used for enumeration.</param>
/// <param name="restrictions">The restrictions to be putted on the retrieved objects set.</param>
/// <param name="sort">Sort expresion to append after ORDER BY clause.</param>
/// <returns>Returns table with Database Objects which satisfy given restriction.</returns>
protected override DataTable ReadTable(DataConnectionWrapper connection, object[] restrictions, string sort)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
// Extract server version
Version serverVersion = connection.ServerVersion;
// For latest version just return base result
if (serverVersion == null || serverVersion.Major >= 5)
{
return(base.ReadTable(connection, restrictions, sort));
}
// Temporary table to store result
DataTable merged = new DataTable();
// Enumerate all tables
DataTable tables = TableDescriptor.Enumerate(connection, restrictions);
// If there is now tables, return empty table with columns
if (tables == null || tables.Rows == null || tables.Rows.Count <= 0)
{
return(merged);
}
// Calculate column restrriction
object column = restrictions != null && restrictions.Length >= 4 ? restrictions[3] : null;
// Enumerate columns for each table
foreach (DataRow tableRow in tables.Rows)
{
// Enumerate columns
DataTable columns = ReadColumnsForTable(
connection,
new object[] {
null,
DataInterpreter.GetString(tableRow, TableDescriptor.Attributes.Schema),
DataInterpreter.GetString(tableRow, TableDescriptor.Attributes.Name),
column
},
sort);
// Merge results if any
if (columns != null)
{
merged.Merge(columns);
}
}
// Return results
return(merged);
}
/// <summary>
/// Returns true if given engine has status.
/// </summary>
/// <param name="engine">Engine name to check.</param>
/// <returns>Returns true if given engine has status.</returns>
private bool HasStatus(string engine)
{
foreach (string candidate in HasStatusList)
{
if (DataInterpreter.CompareInvariant(engine, candidate))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Set state of each flag to checked or unchecked.
/// </summary>
private void FillFlags(DataRow column)
{
string[] keys = new string[flags.Count];
flags.Keys.CopyTo(keys, 0);
// Set checking sate for all items
foreach (string key in keys)
{
// Item is checked depending on the value in the data row
flags[key] = column != null && DataInterpreter.GetSqlBool(column, key).IsTrue;
}
}
/// <summary>
/// Extracts information about all availabel character sets and collations from
/// the DataTable.
/// </summary>
/// <param name="table">DataTable object with data</param>
private void FillCharSetsAndCollations(DataTable table)
{
// Iterate through all collations
foreach (DataRow row in table.Rows)
{
// Extract collation and character set name
string collation = DataInterpreter.GetString(row, CollationName);
string charSet = DataInterpreter.GetString(row, CharSetName);
// Validate names
if (String.IsNullOrEmpty(collation) ||
String.IsNullOrEmpty(charSet))
{
Debug.Fail("Empty collation or character set name!");
continue;
}
// Add character set to list if not already there
if (!characterSetsList.Contains(charSet))
{
characterSetsList.Add(charSet);
}
// Add collation to list
Debug.Assert(!collationsList.Contains(collation), "Dublicate collation name founded!");
if (!collationsList.Contains(collation))
{
collationsList.Add(collation);
}
// Create entry in the collationsForCharacterSet dictionary
if (!collationsForCharacterSetDictionary.ContainsKey(charSet) || collationsForCharacterSetDictionary[charSet] == null)
{
collationsForCharacterSetDictionary[charSet] = new List <string>();
}
List <string> collForCharSet = collationsForCharacterSetDictionary[charSet];
// Add new collation for character set
Debug.Assert(collForCharSet != null &&
!collForCharSet.Contains(collation),
"Empty collation list or dublicate collation!");
if (!collForCharSet.Contains(collation))
{
collForCharSet.Add(collation);
}
// If collation is default, add it to the defaultCollations dictionary
if (DataInterpreter.GetSqlBool(row, IsDefault))
{
Debug.Assert(!defaultCollationsDictionary.ContainsKey(charSet), "Default collation already defined!");
defaultCollationsDictionary[charSet] = collation;
}
}
}
/// <summary>
/// Initializes text property with new name form datasource if any.
/// </summary>
private void RefreshText()
{
if (DataSource == null || String.IsNullOrEmpty(AttributeName))
{
Text = String.Empty;
}
else
{
Text = DataInterpreter.GetStringNotNull(DataSource, AttributeName);
}
}
/// <summary>
/// Reads information about default character set and collation for schema.
/// </summary>
private void ReadDefaulCharacterSetAndCollationForSchema()
{
// Read schema aditional information
DataTable table = RootDescriptor.Enumerate(this, null);
// Exctract default character set and collation names
if (table != null && table.Rows.Count > 0 &&
table.Columns.Contains(RootDescriptor.Attributes.DefaultCharset) &&
table.Columns.Contains(RootDescriptor.Attributes.DefaultCollation))
{
defaultCharacterSetVal = DataInterpreter.GetString(table.Rows[0], RootDescriptor.Attributes.DefaultCharset);
defaultCollationVal = DataInterpreter.GetString(table.Rows[0], RootDescriptor.Attributes.DefaultCollation);
}
}
/// <summary>
/// Returns string with CREATE TABLE sql for the table which owns this index.
/// </summary>
/// <param name="connection">Connection to use to execute query.</param>
/// <param name="row">DataRow with information about index.</param>
/// <returns>Returns string with CREATE TABLE sql for this table.</returns>
private static string GetCreateTableQuery(DataConnectionWrapper connection, DataRow row)
{
// Extract schema and table name
string schemaName = DataInterpreter.GetString(row, Attributes.Schema);
string tableName = DataInterpreter.GetString(row, Attributes.Table);
if (String.IsNullOrEmpty(schemaName) || String.IsNullOrEmpty(tableName))
{
Debug.Fail("Unable to get table or schema name");
return(String.Empty);
}
return(TableDescriptor.GetCreateTableQuery(connection, schemaName, tableName));
}
/// <summary>
/// Fetches data from the results of the SHOW INDEX FROM query to the
/// DataTable with database objects descriptions.
/// </summary>
/// <param name="restrictions">Restricton to apply to the read objects.</param>
/// <param name="table">DataRow with table descriptions for which indexes are enumerated.</param>
/// <param name="indexes">DataTable with results of the SHOW INDEX FROM.</param>
/// <param name="result">DataTable to fill with data.</param>
protected virtual void FetchData(object[] restrictions, DataRow table, DataTable indexes, DataTable result)
{
if (table == null)
{
throw new ArgumentNullException("table");
}
if (indexes == null)
{
throw new ArgumentNullException("indexes");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
// Iterate through results of SHOW INDEX FROM
foreach (DataRow index in indexes.Rows)
{
// Only first columns should be considered
if (DataInterpreter.GetInt(index, SeqInIndex) != 1)
{
continue;
}
// Apply restrictions on the index name, if any
if (!CheckIndexName(restrictions, index))
{
continue;
}
// Create new index row
DataRow row = result.NewRow();
// Fill row with data
DataInterpreter.SetValueIfChanged(row, Attributes.Database, null);
DataInterpreter.SetValueIfChanged(row, Attributes.Schema, table[TableDescriptor.Attributes.Schema]);
DataInterpreter.SetValueIfChanged(row, Attributes.Table, index[Table]);
DataInterpreter.SetValueIfChanged(row, Attributes.Name, index[KeyName]);
DataInterpreter.SetValueIfChanged(row, Attributes.Unique,
DataInterpreter.GetInt(index, NonUnique) == 0 ?
DataInterpreter.True : DataInterpreter.False);
DataInterpreter.SetValueIfChanged(row, Attributes.Primary,
DataInterpreter.CompareInvariant(DataInterpreter.GetStringNotNull(index, KeyName), PRIMARY) ?
DataInterpreter.True : DataInterpreter.False);
DataInterpreter.SetValueIfChanged(row, Attributes.IndexType, index[IndexType]);
// Add filled index row to the results table
result.Rows.Add(row);
}
}
/// <summary>
/// Attaches index columns table to datasource
/// </summary>
private void AttachIndexColumns()
{
DataView view = indexColumns.DataSource is DataView ? indexColumns.DataSource as DataView : new DataView(IndexColumns);
if (view.Table != IndexColumns)
{
view.Table = IndexColumns;
}
view.RowFilter = DataInterpreter.BuildFilter(IndexColumn.Index, SelectedIndexName);
view.Sort = IndexColumn.Ordinal;
indexColumns.DataSource = view;
}
protected void ReadScaleData()
{
DisposeSerialPort();
mSerialPort = new SerialPort
{
BaudRate = mCurrScale.baudRate,
PortName = mCurrScale.com,
DataBits = mCurrScale.dataByte,
StopBits = StopBits.One,
Parity = Parity.None,
};
//设置当前显示控制的解释器。
mScaleDataInterpreter = DataInterpreter.GetDataInterpreter(mCurrScale.brandType, mSerialPort);
}
/// <summary>
/// Attaches foreign jey columns table to datasource
/// </summary>
private void AttachForeignKeyColumns()
{
DataView view = foreigKeyColumns.DataSource is DataView
? foreigKeyColumns.DataSource as DataView : new DataView(ForeignKeysColumns);
if (view.Table != ForeignKeysColumns)
{
view.Table = ForeignKeysColumns;
}
view.RowFilter = DataInterpreter.BuildFilter(ForeignKeyColumn.ForeignKeyName, SelectedKeyName);
foreigKeyColumns.DataSource = view;
}
/// <summary>
/// Fills details view with data for selected index
/// </summary>
private void FillSelectedIndexView()
{
// If selected index is empty, reset view and exit
if (SelectedIndex == null)
{
ResetSelectedIndexView();
return;
}
// Lock selected index updates
lockUpdate = true;
// Fill comboboxes
FillComboboxes();
// Fill index name
indexNameText.DataSource = SelectedIndex;
// If index is primary, need to disable combo-boxes and text boxes
bool enable = !DataInterpreter.CompareInvariant(SelectedIndexName, IndexDescriptor.PRIMARY);
indexNameText.Enabled = enable;
indexKindSelect.Enabled = enable;
indexTypeSelect.Enabled = indexTypeSelect.Enabled && enable;
// If not enabled, there is no value for index kind to select and we should add it
if (!enable && !indexKindSelect.Items.Contains(IndexDescriptor.PRIMARY))
{
indexKindSelect.Items.Add(IndexDescriptor.PRIMARY);
}
// In other case PRIMARY is not allowed
else if (indexKindSelect.Items.Contains(IndexDescriptor.PRIMARY))
{
indexKindSelect.Items.Remove(IndexDescriptor.PRIMARY);
}
// Enable index settings
indexSettingsGroup.Enabled = true;
// Attach grid view to filtered datasource
AttachIndexColumns();
// Select index kind and type
indexKindSelect.SelectedItem = SelectedIndex[Index.IndexKind];
indexTypeSelect.SelectedItem = SelectedIndex[Index.IndexType];
// Unlock selected index updates
lockUpdate = false;
}
/// <summary>
/// Validates a cell of the columns grid
/// </summary>
private void OnCellValidating(object sender, DataGridViewCellValidatingEventArgs e)
{
// Checking only column names
if (e.ColumnIndex != columnNameColumn.Index)
{
return;
}
// Getting a cell value
DataGridViewCell cell = columnsDataGrid[e.ColumnIndex, e.RowIndex];
string cellValue = cell.EditedFormattedValue as string;
// A column name can't be empty
if (string.IsNullOrEmpty(cellValue))
{
e.Cancel = true;
string errorMessage = String.Format(Resources.Error_EmptyColumnName, Document.Name);
UIHelper.ShowError(errorMessage);
isValid = false;
return;
}
// Checking if this cell name duplicates another column name
foreach (DataGridViewRow row in columnsDataGrid.Rows)
{
// Skip current row
if (row.Index == e.RowIndex)
{
continue;
}
// Extract column name
string columnName = row.Cells[e.ColumnIndex].Value as string;
if (string.IsNullOrEmpty(columnName))
{
continue;
}
if (DataInterpreter.CompareInvariant(cellValue, columnName))
{
e.Cancel = true;
string errorMessage = String.Format(Resources.Error_DuplicateColumnName, cellValue);
UIHelper.ShowError(errorMessage);
isValid = false;
return;
}
}
}
/// <summary>
/// Paints the "NULL" image in text cells containing the DBNull value
/// </summary>
/// <param name="e"></param>
protected override void OnCellPainting(DataGridViewCellPaintingEventArgs e)
{
// Filtering header cells
if (e.RowIndex < 0 || e.ColumnIndex < 0)
{
return;
}
// Filtering non-text cells
DataGridViewColumn column = Columns[e.ColumnIndex];
if (column.CellType != typeof(DataGridViewTextBoxCell))
{
return;
}
// Filtering unbound cells
DataGridViewRow row = Rows[e.RowIndex];
DataRowView boundItem = row.DataBoundItem as DataRowView;
if (boundItem == null)
{
return;
}
// Filtering cells having sources with not null values
DataRow dr = boundItem.Row;
if (DataInterpreter.IsNotNull(dr, column.DataPropertyName))
{
return;
}
// A field to paint and a picture
Rectangle cell = e.CellBounds;
Bitmap pic = Resources.Null;
// Painting background
e.PaintBackground(cell, true);
// Painting the required index at the "LeftMiddle"
int x = cell.Left + column.DefaultCellStyle.Padding.Left + 4;
int y = cell.Top + (cell.Height - pic.Height) / 2;
Rectangle picBound = new Rectangle(x, y, pic.Width, pic.Height);
e.Graphics.DrawImageUnscaledAndClipped(pic, picBound);
e.Handled = true;
}
/// <summary>
/// Sets value of given attribute in the column data row.
/// </summary>
/// <param name="attribute">Name of the attribute to set.</param>
/// <param name="value">New value for the atribute</param>
private void SetAttribute(string attribute, object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
// Validate row
if (ColumnRow == null)
{
return;
}
// Validate attribute name
DataInterpreter.SetValueIfChanged(ColumnRow, attribute, value);
}
/// <summary>
/// Fills view with data row data.
/// </summary>
private void RefreshView()
{
// If row is empty, reset view and exit.
if (ColumnRow == null)
{
ResetView();
return;
}
// Disconnect from text box change event handler for default value
// or it will reset null to empty string
defaultValueText.TextChanged -= new EventHandler(OnTextChanged);
// Fill text boxes.
nameText.DataSource = ColumnRow;
datatypeText.Text = DataInterpreter.GetString(ColumnRow, Column.MySqlType);
defaultValueText.Text = DataInterpreter.GetString(ColumnRow, Column.Default);
commentText.Text = DataInterpreter.GetString(ColumnRow, Column.Comments);
// Connect to text box change event handler for default value again
defaultValueText.TextChanged += new EventHandler(OnTextChanged);
// Fill column options.
primaryKey.Checked = DataInterpreter.GetSqlBool(ColumnRow, Column.IsPrimaryKey).IsTrue;
notNull.Checked = DataInterpreter.GetSqlBool(ColumnRow, Column.Nullable).IsFalse;
autoIncrement.Checked = DataInterpreter.GetSqlBool(ColumnRow, Column.IsAutoIncrement).IsTrue;
// Determine datatype and build flags set.
string dataType = DataInterpreter.GetString(ColumnRow, Column.MySqlType);
if (dataType == null)
{
dataType = String.Empty;
}
BuildFlags(dataType);
// Enable or disable comboboxes
charsetSelect.Enabled = collationSelect.Enabled = Parser.SupportCharacterSet(dataType);
// Select caharacter set.
SelectCharacterSet(DataInterpreter.GetString(ColumnRow, Column.CharacterSet));
// Select collation
SelectCollation(DataInterpreter.GetString(ColumnRow, Column.Collation));
}
/// <summary>
/// Returns ordinal value for the new item to be inserted at the end of the table.
/// </summary>
/// <returns>
/// Returns ordinal value for the new item to be inserted at the end of the table.
/// </returns>
private object GetNextValue()
{
if (OrdinalColumn.ValueType != typeof(Int64) &&
OrdinalColumn.ValueType != typeof(UInt64))
{
Debug.Fail("Unsupported ordinal column type!");
return(Rows.Count);
}
// TODO: This will works only with numeric ordinal columns
if (Rows.Count == 0)
{
return(0);
}
DataRow result = ExtractDataRow(Rows[0]);
if (result == null)
{
return(Rows.Count);
}
// TODO: This is a hack to avoid DataGridViewError (default values are not applied
// for the first row if all rows were deleted)
if (!DataInterpreter.IsNotNull(result, OrdinalColumn.DataPropertyName))
{
Rows[0].Cells[OrdinalColumn.Index].Value = 1;
return(Rows.Count);
}
foreach (DataGridViewRow candidate in Rows)
{
if (candidate == null)
{
continue;
}
DataRow dataRow = ExtractDataRow(candidate);
if (dataRow != null && DataInterpreter.IsNotNull(dataRow, OrdinalColumn.DataPropertyName) &&
IsLess(result, dataRow))
{
result = dataRow;
}
}
return(DataInterpreter.GetInt(result, OrdinalColumn.DataPropertyName).Value + 1);
}
/// <summary>
/// Extracts information about all availabel table engines from the DataTable.
/// </summary>
/// <param name="table">DataTable object with data</param>
private void FillTableEngines(DataTable table)
{
// Iterate through all engines
foreach (DataRow engine in table.Rows)
{
// Extract values
string name = DataInterpreter.GetString(engine, EngineDescriptor.Attributes.Name);
SqlBoolean isSupported = DataInterpreter.GetSqlBool(engine, EngineDescriptor.Attributes.IsSupported);
if (engine["Support"].Equals("DISABLED"))
{
isSupported = false;
}
// Validate name
if (String.IsNullOrEmpty(name))
{
Debug.Fail("Empty engine name!");
continue;
}
// Check if engine is not supported
if (isSupported.IsFalse)
{
continue;
}
// Replacing MRG_MyISAM by more readable MERGE
if (DataInterpreter.CompareInvariant(name, TableDescriptor.MRG_MyISAM))
{
name = TableDescriptor.MERGE;
}
// Default engine founded (not YES and not NO - DEFAULT)
if (isSupported.IsNull)
{
Debug.Assert(String.IsNullOrEmpty(defaultEngineVal), "Duplicated default engine!");
defaultEngineVal = name;
}
// Add engine to collaection
if (!enginesList.Contains(name))
{
enginesList.Add(name);
}
}
}
/// <summary>
/// Fetches data from the results of the SHOW INDEX FROM query to the
/// DataTable with database objects descriptions.
/// </summary>
/// <param name="restrictions">Restricton to apply to the read objects.</param>
/// <param name="table">DataRow with table descriptions for which indexes are enumerated.</param>
/// <param name="indexes">DataTable with results of the SHOW INDEX FROM.</param>
/// <param name="result">DataTable to fill with data.</param>
protected override void FetchData(object[] restrictions, DataRow table, DataTable indexes, DataTable result)
{
if (table == null)
{
throw new ArgumentNullException("table");
}
if (indexes == null)
{
throw new ArgumentNullException("indexes");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
// Iterate through results of SHOW INDEX FROM
foreach (DataRow index in indexes.Rows)
{
// Check index name restriction
if (!CheckIndexName(restrictions, index))
{
continue;
}
// Check index column name restriction
if (!CheckIndexColumnName(restrictions, index))
{
continue;
}
// Create new row for index column
DataRow row = result.NewRow();
// Extract data
DataInterpreter.SetValueIfChanged(row, Attributes.Database, null);
DataInterpreter.SetValueIfChanged(row, Attributes.Schema, table[TableDescriptor.Attributes.Schema]);
DataInterpreter.SetValueIfChanged(row, Attributes.Table, index[Table]);
DataInterpreter.SetValueIfChanged(row, Attributes.Index, index[KeyName]);
DataInterpreter.SetValueIfChanged(row, Attributes.Name, index[ColumnName]);
DataInterpreter.SetValueIfChanged(row, Attributes.Ordinal, index[SeqInIndex]);
DataInterpreter.SetValueIfChanged(row, Attributes.IndexLength, index[SubPart]);
// Add new row to the results table
result.Rows.Add(row);
}
}