/// <summary> /// Constructor. /// </summary> /// <param name="log">The logger to use for this metadata source.</param> public BCatalogOnlyMetadataSource(ILogger log, BProperties properties) { LogUtilities.LogFunctionEntrance(log, log); Log = log; m_Properties = properties; try { //get the client connection using (var client = ExternalServiceClient.GetClient(m_Properties.Server)) { //get the catalogs string[] catalogs = client.GetMetadataCatalogs(); //copy results m_Catalogs.AddRange(catalogs); } } catch (Exception ex) { System.Diagnostics.Trace.WriteLine(ex.ToString()); } //m_Catalogs.Add(Driver.B_CATALOG); }
public SpliceConnection( IEnvironment environment) : base(environment) { LogUtilities.LogFunctionEntrance(Log, environment); SetConnectionProperties(); }
/// <summary> /// Constructor. /// </summary> /// <param name="log">The logger to use for this metadata source.</param> public BColumnsMetadataSource(ILogger log, BProperties properties) { LogUtilities.LogFunctionEntrance(log, log); Log = log; m_Properties = properties; //InitializeData(); //List<ColumnInfo> column_infos = new List<ColumnInfo>(); //column_infos.AddRange(m_Columns); //m_Columns.Clear(); try { //get the client connection using (var client = ExternalServiceClient.GetClient(m_Properties.Server)) { //get the columns ColumnMetadataResult[] columns = client.GetMetadataColumns(); //copy results columns.ToList().Where(c => c.Visible).ToList().ForEach(c => { //if(c.Table == "Mentions" && // ( // c.Column == "Id" || // c.Column == "Name" || // c.Column == "Description" || // c.Column == "Type" || // c.Column == "Sentiment" || // c.Column == "Influence" || // c.Column == "IsDisabled" || // c.Column == "OccurredOn" || // c.Column == "CreatedOn" || // c.Column == "UpdatedOn" || // c.Column == "Guid" || // c.Column == "Author" || // c.Column == "Followers" || // c.Column == "Klout" || // c.Column == "Comments" // )) { m_Columns.Add( GetColumnInfo( c.Catalog, c.Table, c.Column, c.DataType, c.ColumnLength, c.Nullable, c.OrdinalPosition, c.ColumnPrecision)); } }); } } catch (Exception ex) { System.Diagnostics.Trace.WriteLine(ex.ToString()); } }
public BQueryExecutor(ILogger log, BProperties properties, string sql) { //get function data LogUtilities.LogFunctionEntrance(log, log, sql); Log = log; m_Properties = properties; Sql = sql; // Create the prepared results. Results = new List <IResult>(); // Create the parameters. ParameterMetadata = new List <ParameterMetadata>(); //create our data IResult result = BResultTableFactory.CreateResultTable(log, sql, properties); if (result != null) { Results.Add(result); } else { throw new Exception("Failed to create the result table."); } }
/// <summary> /// Cancels the currently executing query. /// </summary> public void CancelExecute() { LogUtilities.LogFunctionEntrance(Log); // It's not possible to cancel execution in the UltraLight driver, as there is no actual // 'execution', everything is already hardcoded within the driver. }
/// <summary> /// Checks and updates settings for this connection. /// /// This method is called when attempting to establish a connection to check if the input /// connection settings are valid. This method DOES NOT establish a connection, instead /// Connect() should be called to attempt to establish a connection. This method should /// inspect the input settings and return any modified and additional requested connection /// settings. /// /// If any connection settings have been modified, then a WarningCode.OPT_VAL_CHANGED /// warning must be posted. If a key in the map is unrecognized or does not belong in this /// stage of connection, then a WarningCode.INVALID_CONN_STR_ATTR warning must be posted. /// </summary> /// <param name="requestSettings">Connection settings specified for this connection attempt.</param> /// <returns> /// Connection settings that have been modified, and additional connection settings /// requested that are not present in the input settings. /// </returns> public override Dictionary <string, ConnectionSetting> UpdateConnectionSettings( Dictionary <string, object> requestSettings) { // TODO(ODBC) #03: Check connection settings. // TODO(ADO) #05: Check connection settings. LogUtilities.LogFunctionEntrance(Log, requestSettings); Utilities.NullCheck("requestSettings", requestSettings); Dictionary <string, ConnectionSetting> responseSettings = new Dictionary <string, ConnectionSetting>(); // This method will receive all incoming connection settings as specified in the // connection string. Iterate over the connectionSettings and ensure that values are // specified for each of the keys required to establish a connection. // // If a key is missing, then add it to the returned Dictionary. // // Data validation for the keys should be done in Connect() // // This driver has the following settings: // Required Key: UID - represents a name of a user, could be anything. // Required Key: PWD - represents the password, could be anything. // Optional Key: LNG - represents the language. (NOT USED) VerifyRequiredSetting(Driver.B_SERVER_KEY, requestSettings, responseSettings); VerifyRequiredSetting(Driver.B_UID_KEY, requestSettings, responseSettings); VerifyRequiredSetting(Driver.B_PWD_KEY, requestSettings, responseSettings); VerifyRequiredSetting(Driver.B_CATALOG_KEY, requestSettings, responseSettings); VerifyRequiredSetting(Driver.B_ROWS_TO_FETCH_KEY, requestSettings, responseSettings); VerifyOptionalSetting(Driver.B_RESULT_TYPE_KEY, requestSettings, responseSettings); return(responseSettings); }
/// <summary> /// Indicates that the cursor should be moved to before the first row. /// </summary> /// <returns>True if there are more rows; false otherwise.</returns> public bool MoveToBeforeFirstRow() { LogUtilities.LogFunctionEntrance(Log); m_IsFetching = true; m_Current = 0; return(m_Current < m_Columns.Count); }
/// <summary> /// Attempts to establish a connection to the data source, using connection settings /// generated by a call to UpdateConnectionSettings(). /// </summary> /// <param name="connectionSettings">Connection settings used to authenticate the connection.</param> public override void Connect(Dictionary <string, object> connectionSettings) { // TODO(ODBC) #04: Establish a connection. // TODO(ADO) #06: Establish a connection. LogUtilities.LogFunctionEntrance(Log, connectionSettings); Utilities.NullCheck("connectionSettings", connectionSettings); // The SimbaEngine SDK will call UpdateConnectionSettings() prior to calling this method. // This will ensure that all valid keys required to create a connection have been specified // and are stored within in_connectionSettings. // // This method should validate each of the incoming values and throw an error in the event // of an invalid value. // This driver doesn't validate the given settings, it just requires them. string server = GetRequiredSetting(Driver.B_SERVER_KEY, connectionSettings).ToString(); string uid = GetRequiredSetting(Driver.B_UID_KEY, connectionSettings).ToString(); string pwd = GetRequiredSetting(Driver.B_PWD_KEY, connectionSettings).ToString(); string catalog = GetRequiredSetting(Driver.B_CATALOG_KEY, connectionSettings).ToString(); string strRows = GetRequiredSetting(Driver.B_ROWS_TO_FETCH_KEY, connectionSettings).ToString(); int rows = 1000; Int32.TryParse(strRows, out rows); object objResultType; BProperties.ResultTypes result_type = BProperties.ResultTypes.Normal; GetOptionalSetting(Driver.B_RESULT_TYPE_KEY, connectionSettings, out objResultType); if (objResultType == null) { Enum.TryParse <BProperties.ResultTypes>(objResultType.ToString(), true, out result_type); } if (string.IsNullOrWhiteSpace(uid) || string.IsNullOrWhiteSpace(pwd) || string.IsNullOrWhiteSpace(catalog) || string.IsNullOrWhiteSpace(server)) { throw new Exception("required parameters were not supplied or invalid"); } SetProperty(ConnectionPropertyKey.DSI_CONN_SERVER_NAME, server); SetProperty(ConnectionPropertyKey.DSI_CONN_CURRENT_CATALOG, catalog); SetProperty(ConnectionPropertyKey.DSI_CONN_USER_NAME, uid); m_Properties = new BProperties() { Server = server, UserName = uid, Password = pwd, Catalog = catalog, RowsToFetch = rows, ResultType = result_type }; }
public SpliceDriver() { LogUtilities.LogFunctionEntrance(Log); SetDriverPropertyValues(); // SAMPLE: Adding resource managers here allows you to localize the Simba DotNetDSI and/or ADO.Net components. //Simba.DotNetDSI.Properties.Resources.ResourceManager.AddResourceManager( // new System.Resources.ResourceManager("Simba.UltraLight.Properties.SimbaDotNetDSI", GetType().Assembly)); }
/// <summary> /// Constructor. /// </summary> /// <param name="log">The logger to use for this metadata source.</param> public BTypeInfoMetadataSource(ILogger log) { LogUtilities.LogFunctionEntrance(log, log); Log = log; // Not using the restrictions, allow the SQLEngine to do filtering. InitializeDataTypes(); }
/// <summary> /// Executes the prepared statement for each parameter set provided, or once if there are /// no parameters supplied. /// </summary> /// <param name="contexts"> /// Holds ExecutionContext objects and parameter metadata for execution. There is one /// ExecutionContext for each parameter set to be executed. /// </param> /// <param name="warningListener">Used to post warnings about the execution.</param> public void Execute(ExecutionContexts contexts, IWarningListener warningListener) { LogUtilities.LogFunctionEntrance(Log, contexts, warningListener); //mark all context as success foreach (ExecutionContext context in contexts) { context.Succeeded = true; } }
/// <summary> /// Indicates that the cursor should be moved to the next row. /// </summary> /// <returns>True if there are more rows; false otherwise.</returns> public bool MoveToNextRow() { LogUtilities.LogFunctionEntrance(Log); if (m_IsFetching) { return(false); } m_IsFetching = true; return(true); }
/// <summary> /// Constructor. /// </summary> /// <param name="log">The logger to use for logging.</param> public BResultTable(ILogger log, string sql, BProperties properties) : base(log) { //get the parameters LogUtilities.LogFunctionEntrance(Log, log); m_Properties = properties; Sql = sql; //execute the first fetch ExecuteFetch(m_CurrentPage); }
/// <summary> /// Indicates that the cursor should be moved to the next row. /// </summary> /// <returns>True if there are more rows; false otherwise.</returns> public bool MoveToNextRow() { LogUtilities.LogFunctionEntrance(Log); if (m_IsFetching) { m_Current++; } else { m_IsFetching = true; m_Current = 0; } return(m_Current < m_Tables.Count); }
/// <summary> /// Initialize the column metadata for the result set. /// </summary> public void InitializeColumns(object obj) { LogUtilities.LogFunctionEntrance(Log); //get the info the build the columns ResultEntityType = obj.GetType(); ResultFields = ResultEntityType.GetFields().ToList(); //fields to remove that we do not want in results List <FieldInfo> remove = new List <FieldInfo>(); //parse the fields foreach (var field in ResultFields) { //make sure this not collection type if (field.FieldType.GetInterface("ICollection") != null) { //remove this field remove.Add(field); } else { //create the column DSIColumn column = new DSIColumn(TypeMetadataHelper.CreateTypeMetadata(field.FieldType)); column.IsNullable = Nullability.Nullable; column.Catalog = m_Properties.Catalog; column.Schema = Driver.B_SCHEMA; column.TableName = "Results"; column.Name = field.Name; column.Label = column.Name; if (field.FieldType == typeof(string)) { column.Size = 1000; column.IsSearchable = Searchable.Searchable; } else { column.IsSearchable = Searchable.PredicateBasic; } m_Columns.Add(column); } } //remove the fields foreach (var field in remove) { ResultFields.Remove(field); } }
/// <summary> /// Fills in out_data with the data for a given column in the current row. /// </summary> /// <param name="columnTag">The column to retrieve data from.</param> /// <param name="offset">The number of bytes in the data to skip before copying.</param> /// <param name="maxSize">The maximum number of bytes of data to return.</param> /// <param name="out_data">The data to be returned.</param> /// <returns>True if there is more data in the column; false otherwise.</returns> public bool GetMetadata( MetadataSourceColumnTag columnTag, long offset, long maxSize, out object out_data) { LogUtilities.LogFunctionEntrance(Log, columnTag, offset, maxSize, "out_data"); switch (columnTag) { case MetadataSourceColumnTag.CATALOG_NAME: { out_data = m_Tables[m_Current].Catalog; return(false); } case MetadataSourceColumnTag.SCHEMA_NAME: { out_data = m_Tables[m_Current].Schema; return(false); } case MetadataSourceColumnTag.TABLE_NAME: { out_data = m_Tables[m_Current].Table; return(false); } case MetadataSourceColumnTag.TABLE_TYPE: { out_data = m_Tables[m_Current].TableType; return(false); } case MetadataSourceColumnTag.REMARKS: { out_data = m_Tables[m_Current].Remarks; return(false); } default: { throw ExceptionBuilder.CreateException( "Column Metadata Not Found", columnTag.ToString()); } } }
public override void Connect( Dictionary <String, Object> connectionSettings) { LogUtilities.LogFunctionEntrance(Log, connectionSettings); Utilities.NullCheck("connectionSettings", connectionSettings); _drdaConnection = new DrdaConnection(new DrdaConnectionOptions { Port = Convert.ToInt32(GetRequiredSetting("PORT", connectionSettings)), HostName = Convert.ToString(GetRequiredSetting("HOST", connectionSettings)), UserName = Convert.ToString(GetRequiredSetting("UID", connectionSettings)), Password = Convert.ToString(GetRequiredSetting("PWD", connectionSettings)) }); _drdaConnection.ConnectAsync().Wait(); }
public override Dictionary <String, ConnectionSetting> UpdateConnectionSettings( Dictionary <String, Object> requestSettings) { // TODO(ADO) #05: Check connection settings. LogUtilities.LogFunctionEntrance(Log, requestSettings); Utilities.NullCheck("requestSettings", requestSettings); var responseSettings = new Dictionary <String, ConnectionSetting>(); VerifyRequiredSetting("HOST", requestSettings, responseSettings); VerifyRequiredSetting("PORT", requestSettings, responseSettings); VerifyRequiredSetting("UID", requestSettings, responseSettings); VerifyRequiredSetting("PWD", requestSettings, responseSettings); return(responseSettings); }
public SpliceQueryExecutor( ILogger log) { // TODO(ADO) #09: Implement a QueryExecutor. LogUtilities.LogFunctionEntrance(log, log); _log = log; // Create the prepared results. Results = new List <IResult>(); Results.Add(new DSIRowCountResult(12)); // TODO(ADO) #10: Provide parameter information. ParameterMetadata = new List <ParameterMetadata>(); }
/// <summary> /// Fills in out_data with the data for a given column in the current row. /// </summary> /// <param name="column">The column to retrieve data from, 0 based.</param> /// <param name="offset">The number of bytes in the data to skip before copying.</param> /// <param name="maxSize">The maximum number of bytes of data to return.</param> /// <param name="out_data">The data to be returned.</param> /// <returns>True if there is more data in the column; false otherwise.</returns> public override bool GetData( int column, long offset, long maxSize, out object out_data) { LogUtilities.LogFunctionEntrance(Log, column, offset, maxSize, "out_data"); out_data = null; try { out_data = m_Data[(int)CurrentRow][column]; } catch (Exception ex) { System.Diagnostics.Trace.WriteLine(ex.ToString()); } return(false); }
/// <summary> /// Displays a dialog box that prompts the user for settings for this connection. /// /// The connection settings from io_connectionSettings are presented as key-value string /// pairs. The input connection settings map is the initial state of the dialog box. The /// input connection settings map will be modified to reflect the user's input to the /// dialog box. /// /// The return value for this method indicates if the user completed the process by /// clicking OK on the dialog box (return true), or if the user aborts the process by /// clicking CANCEL on the dialog box (return false). /// /// This dialog is only used for an ODBC driver built with .NET. /// </summary> /// /// <param name="connResponseMap"> /// The connection settings map updated to reflect the user's input. /// </param> /// <param name="connectionSettings"> /// The connection settings map updated with settings that are still needed and were not /// supplied. /// </param> /// <param name="parentWindow"> /// Handle to the parent window to which this dialog belongs /// </param> /// <param name="promptType"> /// Indicates what type of connection settings to request - either both required and /// optional settings or just required settings. /// </param> /// <returns>True if the user clicks OK on the dialog box; false if the user clicks CANCEL. /// </returns> public override bool PromptDialog( Dictionary <string, ConnectionSetting> connResponseMap, Dictionary <string, object> connectionSettings, System.Windows.Forms.IWin32Window parentWindow, PromptType promptType) { LogUtilities.LogFunctionEntrance( Log, connResponseMap, connectionSettings, parentWindow); BConnectionDlg dialog = new BConnectionDlg( connectionSettings, promptType == PromptType.PROMPT_REQUIRED); System.Windows.Forms.DialogResult result = dialog.ShowDialog(parentWindow); return(result == System.Windows.Forms.DialogResult.OK); }
/// <summary> /// Creates a custom metadata source which filters out unneeded rows according to the given /// filters. /// /// Note that filtering must be implemented by the custom result set. /// /// This function works in conjunction with SConnection.GetCustomSchemas(). /// Override GetCustomSchemas() in SConnection to return the list of custom schemas. /// Note that this is only available when using the Simba.NET components. /// </summary> /// <param name="metadataID">Identifier to create the appropriate metadata source.</param> /// <param name="filterValues"> /// Filters to be applied to the metadata table. Appear in column order, with null /// values for columns that are not filtered on. /// </param> /// <param name="escapeChar">Escape character used in filtering.</param> /// <param name="identifierQuoteChar">Character used as a quote around identifiers.</param> /// <param name="filterAsIdentifier">Indicates if string filters are treated as identifiers.</param> /// <returns>A result set object representing the requested metadata.</returns> public override IResultSet MakeNewCustomMetadataResult( string metadataID, IList <object> filterValues, string escapeChar, string identifierQuoteChar, bool filterAsIdentifier) { LogUtilities.LogFunctionEntrance( Log, metadataID, filterValues, escapeChar, identifierQuoteChar, filterAsIdentifier); throw ExceptionBuilder.CreateException( Simba.DotNetDSI.Properties.Resources.INVALID_METADATA_ID, metadataID); }
public void Execute( ExecutionContexts contexts, IWarningListener warningListener) { // TODO(ADO) #11: Implement Query Execution. LogUtilities.LogFunctionEntrance(_log, contexts, warningListener); // The contexts argument provides access to the parameters that were not pushed. // Statement execution is a 3 step process: // 1. Serialize all input parameters into a form that can be consumed by the data // source. If your data source does not support parameter streaming for pushed // parameters, then you will need to re-assemble them from your parameter cache. // See PushParamData. // 2. Send the Execute() message. // 3. Retrieve all output parameters from the server and update the contexts with // their contents. // No action needs to be taken here since the results are static and encapsulated in // ULPersonTable and DSISimpleRowCountResult. }
/// <summary> /// Fills in out_data with the data for a given column in the current row. /// </summary> /// <param name="column">The column to retrieve data from, 0 based.</param> /// <param name="offset">The number of bytes in the data to skip before copying.</param> /// <param name="maxSize">The maximum number of bytes of data to return.</param> /// <param name="out_data">The data to be returned.</param> /// <returns>True if there is more data in the column; false otherwise.</returns> public override bool GetData( int column, long offset, long maxSize, out object out_data) { LogUtilities.LogFunctionEntrance(Log, column, offset, maxSize, "out_data"); //check paging cache if (CurrentRow < m_CurrentPage * m_Properties.RowsToFetch || CurrentRow > ((m_CurrentPage + 1) * m_Properties.RowsToFetch) - 1) { //set the current page m_CurrentPage = CurrentRow / (long)m_Properties.RowsToFetch; //fetch next set of results ExecuteFetch(m_CurrentPage); } //calculate the paging row long PageRow = CurrentRow % m_Properties.RowsToFetch; //get the object object obj = m_Data[(int)PageRow]; //get the value object value = ResultFields[column].GetValue(obj); //check for boolean if (value != null && value.GetType() == typeof(bool)) { out_data = Convert.ToByte(value); } else { out_data = value; } //throw new Exception("testing"); return(false); }
/// <summary> /// Prepare the given SQL query for execution. /// /// An IQueryExecutor is returned which will be used to handle query execution. /// </summary> /// <param name="sqlQuery">The SQL query to prepare.</param> /// <returns>An IQueryExecutor instance that will handle the query execution.</returns> public override IQueryExecutor Prepare(string sqlQuery) { // TODO(ODBC) #06: Prepare a query. // TODO(ADO) #08: Prepare a query. LogUtilities.LogFunctionEntrance(Log, sqlQuery); // This is the point where you will send the request to your SQL-enabled data source for // query preparation. You will need to provide your own implementation of IQueryExecutor // which should wrap your statement context to the prepared query. // // Query preparation is really a 3 part process and is described as follows: // 1. Generate and send the request to your data source for query preparation. // 2. Handle the response and for each statement in the query retrieve its column // metadata information prior to query execution. You will need to derive from // DSISimpleResultSet to create your representation of a result set. // See ULPersonTable. // 3. Create an instance of IQueryExector seeding it with the results of the query. // See ULQueryExecutor. // Determine if doing a SELECT or DML/DDL via very, very simple parsing. //string query = sqlQuery.ToLower(); //bool isSelect = (-1 != query.IndexOf("select")); //bool isParameterized = (-1 != query.IndexOf("?")); //bool isProcedure = (-1 != query.IndexOf("{call")); //// Example of how to throw a parsing error. //if (isProcedure) //{ // throw ExceptionBuilder.CreateException( // String.Format(Simba.DotNetDSI.Properties.Resources.INVALID_QUERY, query)); //} //trace the execute System.Diagnostics.Trace.WriteLine(string.Format("**********************\r\nQueryExecution\r\n{0}\r\n***************************", sqlQuery)); return(new BQueryExecutor(Log, m_Properties, sqlQuery)); }
/// <summary> /// Constructor. /// </summary> /// <param name="log">The logger to use for logging.</param> public BFakeResultTable(ILogger log, string sql, BProperties properties) : base(log, sql, properties) { //set parameters LogUtilities.LogFunctionEntrance(Log, log); m_Properties = properties; Sql = sql; //init the columns try { using (var client = ExternalServiceClient.GetClient(m_Properties.Server)) { m_TableColumns = client.GetMetadataColumns(); } } catch (Exception ex) { System.Diagnostics.Trace.WriteLine(ex.ToString()); } //make the fake data InitializeFakeData(Sql); }
/// <summary> /// Fills in out_data with the data for a given column in the current row. /// </summary> /// <param name="columnTag">The column to retrieve data from.</param> /// <param name="offset">The number of bytes in the data to skip before copying.</param> /// <param name="maxSize">The maximum number of bytes of data to return.</param> /// <param name="out_data">The data to be returned.</param> /// <returns>True if there is more data in the column; false otherwise.</returns> public bool GetMetadata( MetadataSourceColumnTag columnTag, long offset, long maxSize, out object out_data) { LogUtilities.LogFunctionEntrance(Log, columnTag, offset, maxSize, "out_data"); switch (columnTag) { case MetadataSourceColumnTag.SCHEMA_NAME: { out_data = Driver.B_SCHEMA; return(false); } default: { throw ExceptionBuilder.CreateException( "Column Not Found", columnTag.ToString()); } } }
/// <summary> /// Indicates that the cursor should be moved to the next row. /// </summary> /// <returns>True if there are more rows; false otherwise.</returns> protected override bool MoveToNextRow() { LogUtilities.LogFunctionEntrance(Log); return(CurrentRow < RowCount); }
/// <summary> /// Closes the result set's internal cursor. After a call to this method, no /// more calls will be made to MoveToNextRow() and GetData(). /// </summary> protected override void DoCloseCursor() { LogUtilities.LogFunctionEntrance(Log); }
/// <summary> /// Initialize the fake data /// </summary> public void InitializeFakeData(string sql) { LogUtilities.LogFunctionEntrance(Log); List <object> fake_row = new List <object>(); string sql_no_select = sql.Substring(sql.IndexOf("SELECT ") + 7); string sql_no_top = sql_no_select; if (sql_no_select.IndexOf("TOP ") != -1) { sql_no_top = sql_no_select.Substring(sql_no_select.IndexOf("TOP ") + 4).Trim(); sql_no_top = sql_no_top.Substring(sql_no_top.IndexOf(" ") + 1).Trim(); } string sql_no_from = sql_no_top.Substring(0, sql_no_top.IndexOf("FROM ")); string[] columns_with_alias = sql_no_from.Split(','); foreach (var field_alias in columns_with_alias) { string[] aliases = field_alias.Split(new string[] { " AS ", " as " }, StringSplitOptions.None); string field = ""; string alias = ""; if (aliases.Length > 0) { field = aliases[0].Trim(); } if (aliases.Length > 1) { alias = aliases[1].Trim(); } field = field.Replace("\"", ""); alias = alias.Replace("\"", ""); string table = ""; if (field.IndexOf('.') != -1) { table = field.Substring(0, field.IndexOf('.')); field = field.Substring(field.IndexOf('.') + 1); } var column_meta = m_TableColumns.Where(c => c.Table == table && c.Column == field).FirstOrDefault(); Type type; bool added = false; if (column_meta != null) { type = Type.GetType(column_meta.DataType); } else { double num; if (double.TryParse(field, out num)) { type = typeof(double); fake_row.Add(num); added = true; } else { type = typeof(string); fake_row.Add(field); } } if (!added) { if (type == typeof(string)) { fake_row.Add("FakeData"); } else if (type == typeof(DateTime)) { fake_row.Add(DateTime.UtcNow); } else if (type == typeof(bool)) { byte b = 0; fake_row.Add(b); } else { fake_row.Add(Activator.CreateInstance(type)); } } DSIColumn column = new DSIColumn(TypeMetadataHelper.CreateTypeMetadata(type)); column.IsNullable = Nullability.Nullable; column.Catalog = m_Properties.Catalog; column.Schema = Driver.B_SCHEMA; column.TableName = "Results"; column.Name = alias; column.Label = alias; if (type == typeof(string)) { column.Size = 1000; column.IsSearchable = Searchable.Searchable; } else { column.IsSearchable = Searchable.PredicateBasic; } m_Columns.Add(column); } RowCount = 10; for (int x = 0; x < RowCount; x++) { m_Data.Add(fake_row); } }