/// <summary> /// Save a message in the database /// </summary> /// <param name="message"></param> public void SaveMessage(DataAccessLayer.User sender, Message message) { message.Validate(sender); ITableRow tableRow = message.ConvertToTableRow(); MessageTable.Instance.InsertRow(tableRow); }
public void ReadParameter( ConnectionGroupInfo connectionGroup, Int64 queryId, TemplateNodeQueryInfo query, ParameterValue paramValue ) { Int64?parameterId = GetParameterId(connectionGroup, query, paramValue.Name); if (parameterId != null) { List <ITableRow> rows = this.GetRows( QueryIdFn + " = " + queryId + " AND " + ParameterIdFn + " = " + parameterId ); if (rows != null) { if (rows.Count != 0) { ITableRow paramRow = rows.ElementAt(0); paramValue.UserValue = paramRow.GetValue <string>(ValueFn); } } } }
public NewRowItemViewModel(Authentication authentication, ITableRow row, ColumnInfo columnInfo) { this.authentication = authentication; this.row = row; this.columnInfo = columnInfo; this.value = row[columnInfo.Name]; }
public void MoveLeft(ITableRow row, TaskContext context) { if (object.Equals(context.State, System.Data.DataRowState.Detached) == true) { return; } }
public static ServerInstanceRow Copy(ITableRow sourceRow) { ServerInstanceRow row = new ServerInstanceRow(); sourceRow.CopyValues(row); return(row); }
private bool?GetChildrenNotYetProcessed(Int64 nodeInstanceId) { ITableRow row = this.GetRowByIdentity(nodeInstanceId); return(row != null ? (bool)row.Values[ChildrenNotYetProcessedFn] : (bool?)null); }
public static void ModifyTableRow(ITableRow row, Int64 queryId, Int64 sessionId, Int64 rowOrder, string rowhash) { row.Values.Add(QueryDirectory.TableName.AsFk(), queryId); row.Values.Add(MetaResultTable.SessionIdFieldName, sessionId); row.Values.Add(RowOrderFieldName, rowOrder); row.Values[RowHashFieldName] = rowhash; }
public static void ModifyTableRow(ITableRow row, Int64 queryId, Int64 sessionId, Int64 rowOrder, string rowhash) { row.Values.Add(QueryDirectory.TableName.AsFk(), queryId); row.Values.Add(MetaResultTable.SessionIdFieldName, sessionId); row.Values.Add(RowOrderFieldName, rowOrder); row.Values[RowHashFieldName] = rowhash; }
public static TRow Convert <TRow>(ITableRow sourceRow) where TRow : ITableRow, new() { TRow row = new TRow(); sourceRow.CopyValues(row); return(row); }
public async Task MoveLeftAsync(ITableRow row, TaskContext context) { if (object.Equals(context.State, System.Data.DataRowState.Detached) == true) { return; } await Task.Delay(0); }
public ITableRow NewRow() { ITableRow row = CreateRow(); AddRow(row); return(row); }
internal int?GetRowCount(TemplateNodeInfo node) { Debug.Assert(node.IsInstance); int cachedValue = 0; int?rowsTotal = null; if (node.TemplateNodeId == null) { return(null); } if (this._nodesRowCountCache.TryGetValue(node.TemplateNodeId.Value, out cachedValue)) { return(cachedValue); } foreach (InstanceInfo serverInstance in node.ConnectionGroup.Connections) { foreach (TemplateNodeQueryInfo tqi in node.Queries) { Int64?queryId = this.QueryDirectory.GetQueryId( node, tqi, serverInstance, new DateTime(), true ); if (queryId == null) { continue; } if (rowsTotal == null) { rowsTotal = 0; } ITableRow lastMetaRow = this.ReadLastMeta(queryId.Value); rowsTotal += lastMetaRow != null ? (int)(Int64)lastMetaRow.Values[MetaResultTable.RowCountFieldName] : 0; } } if (rowsTotal == null) { return(null); } this._nodesRowCountCache.AddOrUpdate(node.TemplateNodeId.Value, id => rowsTotal.Value, (id, old) => rowsTotal.Value); //NodeInstances.SetReportsRowCountTotal(node.PrimaryKey.Value, rowsTotal.Value); return(rowsTotal.Value); }
protected void ExportToPdfButton_Click(object sender, EventArgs e) { ReportFactory.SetStyle1ForPDF(); PdfDocument document = new PdfDocument(PageSize.A4); document.PageOrientation = PageOrientation.Landscape; ITable table = document.NewTable(2); ITableRow row1 = table.NewRow(); row1.BackgoundColor = ReportColor.Red; row1.TextColor = ReportColor.While; ITableCell cell11 = row1.NewCell(); cell11.Value = "Tiêu đề báo cáo"; cell11.HorizontalAlignment = HorizontalAlignment.Center; cell11.Colspan = 2; ITableCell cell21 = row1.NewCell(); cell21.Value = "Tiêu đề báo cáo 2"; cell21.HorizontalAlignment = HorizontalAlignment.Left; ITableRow row2 = table.NewRow(); ITableCell cell12 = row2.NewCell(); cell12.Value = "Tiêu đề báo cáo dòng 2"; cell12.HorizontalAlignment = HorizontalAlignment.Right; IParagraph p1 = new Paragraph("Hướng dẫn sử dụng thư viện xuất ra tệp PDF."); IText textBold = new Text(" Bold"); textBold.Style = FontStyle.Bold; p1.AddText(textBold); document.AddElement(p1); IParagraph p2 = new Paragraph("Hướng dẫn sử dụng thư viện xuất ra tệp PDF."); p2.PaddingBottom = 10f; IText textBold2 = new Text(" Bold"); textBold2.Style = FontStyle.Bold; p2.AddText(textBold); document.AddElement(p2); document.InsertFromExcel(MapPath("~/Uploads/data_empty.xlsx")); document.InsertFromExcel(MapPath("~/Uploads/data.xlsx")); document.Save(MapPath("~/Uploads/b.pdf")); }
public NewRowItemViewModel(Authentication authentication, ITableRow row, ColumnInfo columnInfo, TypeInfo typeInfo) { this.authentication = authentication; this.row = row; this.columnInfo = columnInfo; this.typeInfo = typeInfo; this.Items = typeInfo.Members.Select(item => (object)item).ToArray(); this.value = row[columnInfo.Name]; }
private void PopulateUserInfo(ITableRow row) { TimetableUserEntry userEntry = _userRepository.GetByUsername(row.UserId); if (userEntry != null) { PopulateUserInfo(row, userEntry); } }
private void RenderTableRow(TableRowLayout layout, ITable table) { ITableRow row = table.AddRow((s.TableRowStyle)layout.Style, layout.TrackingInfo); foreach (TableCellLayout cell in layout.SubLayouts) { RenderTableCell(cell, row); } }
public void SendRow(string routerName, ITableRow row, string action) { var socket = RouterNameToSocket[routerName]; byte[] data = Encoding.ASCII.GetBytes($"{action} {row.Serialize()}"); socket.Send(data); Thread.Sleep(100); AddLog($"Sending to {routerName}: {action} {row}", LogType.Information); }
private void NotifyOfEvent(DatabaseEvent.EAction action, ITableRow row) { ion.PostToMain(() => { if (onDatabaseEvent != null) { onDatabaseEvent(this, new DatabaseEvent(action, row.GetType(), row._id)); } }); }
private void RenderTableCell(TableCellLayout layout, ITableRow row) { ITableCell cell = row.AddCell(layout.ColumnSpan, (s.TableCellStyle)layout.Style, layout.TrackingInfo); foreach (Layout sublayout in layout.SubLayouts) { Render(sublayout, cell); } }
/// <summary> /// Get row id of row according values /// </summary> /// <param name="row">Row to search</param> /// <returns></returns> protected Int64?GetRow(ITableRow row) { string clause = null; List <SQLiteParameter> parameters = null; this.GetQueryDataForRow(row, out clause, out parameters); return(this.GetRowIdentity(clause, parameters)); }
private ITable CreateReplacementTable() { WriterClass.writeln("Exclusion Table Info:"); // Show possible columns, their names, help and value options ITable replacementTable = m_methods.CreateTable(typeof(IExclusionTable)); foreach (ITableColumnDescription col in replacementTable.ColumnInfo) { log.Info("{0,-12} {1,-25} {2}", col.Name, col.Selection, (col.Help ?? "").Trim().Replace("\r", "").Replace("\n", "; ")); WriterClass.writeln(String.Format("{0,-12} {1,-25} {2}", col.Name, col.Selection, (col.Help ?? "").Trim().Replace("\r", "").Replace("\n", "; "))); if (col.AcceptedHeaderNames.Length > 0) { log.Info("{0,38} alternative names: {1}", "", string.Join(", ", col.AcceptedHeaderNames)); WriterClass.writeln(String.Format("{0,38} alternative names: {1}", "", string.Join(", ", col.AcceptedHeaderNames))); } } WriterClass.Flush(); WriterClass.writeln("======================================\n"); WriterClass.writeln("Now attempting to write default value\n"); foreach (ITableColumnDescription col in replacementTable.ColumnInfo) { log.Info("{0,-12} {1,-25} {2} Default Value: {3}; Optional: {4}", col.Name, col.Selection, (col.Help ?? "").Trim().Replace("\r", "").Replace("\n", "; "), col.DefaultValue, col.Optional.ToString()); WriterClass.writeln(String.Format("{0,-12} {1,-25} {2} Default Value: {3}; Optional: {4}", col.Name, col.Selection, (col.Help ?? "").Trim().Replace("\r", "").Replace("\n", "; "), col.DefaultValue, col.Optional.ToString())); if (col.AcceptedHeaderNames.Length > 0) { log.Info("{0,38} alternative names: {1}", "", string.Join(", ", col.AcceptedHeaderNames)); WriterClass.writeln(String.Format("{0,38} alternative names: {1}", "", string.Join(", ", col.AcceptedHeaderNames))); } } WriterClass.Flush(); if (GlobalVar.SetExclusionTable) { log.Info("Attempting to set exclusio table values"); //// Create a new table with two rows. ITableRow row = replacementTable.CreateRow(); row.ColumnValues["Polarity"] = "Positive"; // must match, PRM has a polarity setting row.ColumnValues["Mass [m/z]"] = "700"; replacementTable.Rows.Add(row); row = replacementTable.CreateRow(); row.ColumnValues["Polarity"] = "Negative"; row.ColumnValues["Mass [m/z]"] = "1600"; replacementTable.Rows.Add(row); } else { replacementTable = null; } return(replacementTable); }
public ServerProperties GetServerProperties( InstanceInfo instance ) { ConnectionGroupInfo connectionGroup = instance.ConnectionGroup; connectionGroup.ReadGroupIdFrom(Storage.ConnectionGroupDirectory); Int64?loginId = Storage.LoginDirectory.GetId(instance); string clause = string.Join(" AND ", new List <string> { ConnectionGroupIdFn.AsSqlClausePair(), LoginIdFn.AsSqlClausePair(), ConnectionNameFn.AsSqlClausePair(), DbTypeFn.AsSqlClausePair(), IsDynamicConnectionFn.AsSqlClausePair() } ); List <ITableRow> rows = this.GetRows( clause, new List <SQLiteParameter> { SQLiteHelper.GetParameter(ConnectionGroupIdFn, connectionGroup.Identity), SQLiteHelper.GetParameter(LoginIdFn, loginId), SQLiteHelper.GetParameter(ConnectionNameFn, instance.Name), SQLiteHelper.GetParameter(DbTypeFn, instance.DbType), SQLiteHelper.GetParameter(IsDynamicConnectionFn, instance.IsDynamicConnection) }, 1 ); if (rows != null) { if (rows.Count != 0) { ITableRow row = rows.ElementAt(0); string version = row.GetValue <string>(ServerInstanceVersionFn); string name = row.GetValue <string>(ServerInstanceNameFn); if (!string.IsNullOrEmpty(version)) { return(new ServerProperties( new InstanceVersion(version), name, DateTime.Now )); } } } return(null); }
public LastConnectionProtocolRow GetRow(long lastConnectionId) { ITableRow row = GetRowByIdentity(lastConnectionId); if (row == null) { return(null); } return(RowConverter.Convert <LastConnectionProtocolRow>(row)); }
public TemplateRow GetTemplate(long templateId) { ITableRow row = GetRowByIdentity(templateId); if (row != null) { return(RowConverter.Convert <TemplateRow>(row)); } return(null); }
public async Task SetTagsAsync(ITableRow row, TaskContext context) { var authentication = context.Authentication; if (object.Equals(context.State, System.Data.DataRowState.Detached) == true) { return; } var tags = TagInfoUtility.Names.Random(); await row.SetTagsAsync(authentication, (TagInfo)tags); }
public async Task SetIsEnabledAsync(ITableRow row, TaskContext context) { var authentication = context.Authentication; if (object.Equals(context.State, System.Data.DataRowState.Detached) == true) { return; } var isEnabled = RandomUtility.NextBoolean(); await row.SetIsEnabledAsync(authentication, isEnabled); }
public ConnectionGroupRow GetGroupById(long id) { ITableRow row = this._storage.ConnectionGroupDirectory.GetRowByIdentity(id); if (row == null) { return(null); } return(RowConverter.Convert <ConnectionGroupRow>(row)); }
void ITableContent.EndNew(Authentication authentication, ITableRow row) { if (row == null) { throw new ArgumentNullException(nameof(row)); } if (row is TableRow == false) { throw new ArgumentException(Resources.Exception_InvalidObject, nameof(row)); } this.EndNew(authentication, row as TableRow); }
protected void ExportToPdfMergeRowButton_Click(object sender, EventArgs e) { ReportFactory.SetStyle1ForPDF(); PdfDocument document = new PdfDocument(PageSize.A0); document.PageOrientation = PageOrientation.Landscape; document.InsertFromExcel(MapPath("~/Uploads/Report_4_TongHopCallReport.xlsx")); ReportColor green = ReportColor.Create(0, 100, 45); ReportColor textHong = ReportColor.Create(230, 184, 183); ReportColor textKhds = ReportColor.Create(99, 37, 35); ReportColor textKhln = ReportColor.Create(118, 147, 60); ReportColor textThds = ReportColor.Create(96, 73, 122); ReportColor textThln = ReportColor.Create(49, 134, 155); document.Save(MapPath("~/Uploads/Report_4_TongHopCallReport.pdf"), (paragraphs) => { foreach (IElementRoot paragraph in paragraphs) { if (paragraph is ITable) { ITable table = paragraph as ITable; ITableRow row1 = table.Rows[0]; for (int i = 1; i <= row1.Cells.Count; i++) { ITableCell cell = row1.Cells[i - 1]; cell.BackgoundColor = green; if (i > 3) { cell.TextColor = textHong; } else { cell.TextColor = ReportColor.While; } } ITableRow row3 = table.Rows[2]; for (int i = 1; i <= row3.Cells.Count; i++) { ITableCell cell = row3.Cells[i - 1]; cell.TextColor = ReportColor.While; cell.BackgoundColor = green; } } } return(paragraphs); }); }
public void Delete(ITableRow row, TaskContext context) { row.Dispatcher.Invoke(() => { if (object.Equals(context.State, System.Data.DataRowState.Detached) == false) { row.Delete(context.Authentication); context.State = System.Data.DataRowState.Deleted; context.Complete(row); } }); }
public async Task DeleteAsync(ITableRow row, TaskContext context) { var authentication = context.Authentication; if (object.Equals(context.State, System.Data.DataRowState.Detached) == false) { await row.DeleteAsync(authentication); context.State = System.Data.DataRowState.Deleted; context.Pop(row); } }
public RowUpdateByHashCommand( SQLiteConnection connection, TableDefinition tableDefinition ) : base( connection, tableDefinition ) { this._clause = null; this._setString = null; this._updateTable = false; this._parameters = null; this._row = null; this._transaction = null; }
public void SetCommandConstraints( string clause, List<SQLiteParameter> parameters, string setString, bool updateTable, ITableRow row, SQLiteTransaction transaction = null ) { this._clause = clause; this._parameters = parameters; this._setString = setString; this._updateTable = updateTable; this._row = row; this._transaction = transaction; }
public static Message ConvertToMessage(ITable table, ITableRow tableRow) { Message message = null; if (table.BlobValueColumn != null) { byte[] value = (byte[])tableRow.ColumnValues[table.BlobValueColumn]; message = MessageSerializer.DeSerializeFromProtocolBuffer(value); } else { message = new Message(); } DataContractToTableRowConverter.SetYapperColumnValues(message, tableRow); return message; }
internal object Execute(ITableRow row) { this.connection.StartTransaction(System.Data.IsolationLevel.ReadCommitted); // Save the blob first if (table.BlobValueColumn != null && table.BlobNameColumn != null) { object guidObject = null; Guid blobName = Guid.Empty; if (!row.ColumnValues.TryGetValue(table.BlobNameColumn, out guidObject)) { blobName = Guid.NewGuid(); row.ColumnValues.Add(table.BlobNameColumn, blobName); } else { blobName = (Guid)guidObject; } object blobValue = null; if (!row.ColumnValues.TryGetValue(table.BlobValueColumn, out blobValue)) { row.ColumnValues[table.BlobNameColumn] = Guid.Empty; blobName = Guid.Empty; } IBlobStore blobStore = BlobStoreFactory.Instance.GetBlobStore(); blobStore.SaveBlob(row.BlobContainer, blobName.ToString(), (byte[])blobValue); } // Save the row in the table DbCommand command = this.BuildInsertCommand(row); if (table.Identity != null) { SqlParameter outParameter = new SqlParameter(string.Format("@{0}", table.Identity.Name), DatabaseInsertOperator.GetSqlType(table.Identity.Type)); outParameter.Direction = ParameterDirection.Output; command.Parameters.Add(outParameter); } object outParam = command.ExecuteScalar(); this.connection.CommitTransaction(); return null; }
public void DecryptFrom(ITableRow encryptedRow, ICryptoService cryptoService) { encryptedRow.CopyValues(this); foreach (string encryptedField in EncryptedStringFields) { if (this.TableDefinition.Fields.ContainsKey(encryptedField)) { FieldDefinition def = this.TableDefinition.Fields[encryptedField]; if (def.SqlType == SqlDbType.NVarChar) { string decryptedValue = cryptoService.Decrypt(GetValue<string>(encryptedField)); SetValue(encryptedField, decryptedValue); } } } }
public ITableRow InsertRow(ITableRow row) { // Validate that we are attempting to insert only the columns that // exist in the table foreach (IColumn column in row.ColumnValues.Keys) { if (!this.Columns.Contains(column)) { throw new Exception("Attempting to insert a column that doesn't exist in the table"); } } foreach (IColumn column in this.Columns) { if (column.IsRequired && !row.ColumnValues.ContainsKey(column)) { throw new Exception("Value for required column not present"); } } if (this.Identity != null && row.ColumnValues.ContainsKey(this.Identity)) { throw new Exception("Value should not be set for identity column"); } using (DatabaseInsertOperator insertOp = new DatabaseInsertOperator(this)) { object identity = insertOp.Execute(row); if (this.Identity != null) { row.ColumnValues.Add(this.Identity, identity); } } return row; }
/// <summary> /// Update one row by row identity /// </summary> /// <param name="row">Row to update</param> public void UpdateRow(ITableRow row) { this.UpdateRows(new[] { row }); }
/// <summary> /// Find or create row according values /// </summary> /// <param name="row">Row to search or create</param> /// <param name="beforeRowUpdate">Code to be executed before row update. If null no update executes.</param> /// <param name="beforeRowAdd">Code to be executed before row insert</param> /// <returns></returns> public Int64? InsertOrUpdateRow( ITableRow row, Action<ITableRow> beforeRowUpdate = null, Action<ITableRow> beforeRowAdd = null ) { Int64? identity = null; string clause = null; List<SQLiteParameter> parameters = null; List<ITableRow> result = null; this.GetQueryDataForRow(row, out clause, out parameters); using (this.Connection.OpenWrapper()) { result = this.GetRows(clause, parameters, 1); if (result != null && result.Count > 0) { // Log.DebugFormat("Record exists(1):Count:'{0}'", // result.Count // ); ITableRow existRow = result.First(); if (beforeRowUpdate != null) { beforeRowUpdate(row); } if (row.CopyValues(existRow)) { this.UpdateRow(existRow); } identity = (long?) existRow.Values[IdentityField]; } else { // Log.Debug("Record is not exists"); lock (this.GetLockObject()) { // // try to get the record again as the record can be already added by the differect thread // result = this.GetRows(clause, parameters, 1); if (result != null && result.Count > 0) { // Log.DebugFormat("Record exists(2):Count:'{0}'", // result.Count // ); ITableRow existRow = result.First(); if (beforeRowUpdate != null) { beforeRowUpdate(row); if (row.CopyValues(existRow)) { this.UpdateRow(existRow); } } identity = (long?) existRow.Values[IdentityField]; } else { if (beforeRowAdd != null) { beforeRowAdd(row); } identity = this.AddRow(row); } } } } return identity; }
public Int64? InsertOrUpdateRowForSure(ITableRow row) { // // without r => { } the records can't be updated // return this.InsertOrUpdateRow(row, r => { }); }
/// <summary> /// Get row id of row according values /// </summary> /// <param name="row">Row to search</param> /// <returns></returns> protected Int64? GetRow(ITableRow row) { string clause = null; List<SQLiteParameter> parameters = null; this.GetQueryDataForRow(row, out clause, out parameters); return this.GetRowIdentity(clause, parameters); }
/// <summary> /// Add row to table /// </summary> /// <param name="row">Row to add</param> /// <returns></returns> public Int64? AddRow(ITableRow row) { return this.AddRows(new[] { row }); }
public void ComposeTableRow(TemplateNodeInfo node, out ITableRow nodeRow, out List<ITableRow> attributesRows) { Debug.Assert(node.IsInstance); Int64? parentNodeId = null; if (node.Parent != null) { if (node.Parent.TemplateNodeId == null) { throw new InvalidOperationException(node + ": it's parent is not saved (has no id)"); } parentNodeId = node.Parent.TemplateNodeId; } nodeRow = new TableRow(this.TableDefinition); node.ConnectionGroup.ReadGroupIdFrom(this._storage.ConnectionGroupDirectory); nodeRow.Values.Add( ConnectionIdFn, node.ConnectionGroup.Identity ); nodeRow.Values.Add( TemplateNodeIdFn, this._storage.TemplateNodeDirectory.GetId(node.ConnectionGroup, node.Template) ); nodeRow.Values.Add(ParentIdFn, parentNodeId); nodeRow.Values.Add(NodeUIdFn, node.UId); nodeRow.Values.Add(NodeUNameFn, node.UName); nodeRow.Values.Add(NodeUIconFn, node.IconImageReferenceName); nodeRow.Values.Add(NodeEnabledFn, !node.IsDisabled); nodeRow.Values.Add(NodeFontColorFn, node.FontColor); nodeRow.Values.Add(NodeFontStyleFn, node.FontStyle); if (node.CounterValue != null) { nodeRow.Values.Add(NodeCounterValue, node.CounterValue); } nodeRow.Values.Add( NodeSequenceNumberFn, node.Parent != null ? node.Parent.Childs.IndexOf(node) : 0 ); List<TemplateNodeUpdateJob> jobs = node.GetRefreshJob(true); foreach (TemplateNodeUpdateJob job in jobs) { if (job != null && job.LastRan != null) { nodeRow.Values.Add(NodeScheduledUpdateFn, job.LastRan); } } attributesRows = new List<ITableRow>(); foreach (KeyValuePair<string, string> pair in node.Attributes.Values) { ITableRow row = new TableRow(NodeInstanceAttributeTable.CreateTableDefinition()); row.Values.Add(NodeInstanceAttributeTable.NameFn, pair.Key); row.Values.Add(NodeInstanceAttributeTable.ValueFn, pair.Value); attributesRows.Add(row); } }
public void AddRowForReplacing(ITableRow row) { this._rows.Add(row); }
private DbCommand BuildInsertCommand(ITableRow row) { StringBuilder columns = new StringBuilder(); StringBuilder columnParameters = new StringBuilder(); foreach (IColumn column in row.ColumnValues.Keys) { if (column.ColumnLocation == ColumnLocation.Database) { columns.AppendFormat("{0},", column.Name); columnParameters.AppendFormat("@{0},", column.Name); } } columns.Remove(columns.Length - 1, 1); columnParameters.Remove(columnParameters.Length - 1, 1); string query = string.Format( DatabaseInsertOperator.InsertQueryFormat, this.table.Name, columns.ToString(), columnParameters.ToString(), this.table.Identity == null ? string.Empty : DatabaseInsertOperator.ScopeIdentity); DbCommand command = this.connection.CreateCommand(query); // Add the parameters to the SQL command foreach (IColumn column in row.ColumnValues.Keys) { if (column.ColumnLocation == ColumnLocation.Database) { command.Parameters.Add(this.connection.CreateParameter(string.Format("@{0}", column.Name), row.ColumnValues[column])); } } return command; }
public bool DeleteRow(ITableRow row) { return false; }
public LoginRow Encrypt(ITableRow row, ICryptoService cipher) { base.EncryptFrom(row, cipher); return this; }
public static ServerInstanceRow Copy(ITableRow sourceRow) { ServerInstanceRow row = new ServerInstanceRow(); sourceRow.CopyValues(row); return row; }
/// <summary> /// Prepare the query to the table data /// </summary> /// <param name="row">table row</param> /// <returns></returns> private void GetQueryDataForRow(ITableRow row, out string clause, out List<SQLiteParameter> parameters) { List<string> clauses = new List<string>(); parameters = new List<SQLiteParameter>(); foreach (FieldDefinition field in this.TableDefinition.Fields.Values) { if (field.Unique) { if (row.Values[field.Name] != null) { clauses.Add(field.Name.AsSqlClausePair()); SQLiteParameter param = new SQLiteParameter(field.Name.AsParamName(), field.SqlType.ToDbType()) { Value = row.Values[field.Name] ?? DBNull.Value }; parameters.Add(param); } else { clauses.Add(string.Format("{0} IS NULL", field.Name)); } } } // the code bellow is needed to support the calculation of the "clause" based on unique // indexes composed from 2 or more fields if (clauses.Count == 0) { foreach (IndexDefinition indDef in this.TableDefinition.Indexes) { if (indDef.IsComposedUnique) { foreach (string fieldName in indDef.FieldNames) { FieldDefinition field = this.TableDefinition.Fields[fieldName]; if (row.Values[field.Name] != null) { clauses.Add(field.Name.AsSqlClausePair()); SQLiteParameter param = new SQLiteParameter(field.Name.AsParamName(), field.SqlType.ToDbType()) { Value = row.Values[field.Name] ?? DBNull.Value }; parameters.Add(param); } else { clauses.Add(string.Format("{0} IS NULL", field.Name)); } } } } } clause = clauses.Join(" AND "); }
public void AddRowForUpdating(ITableRow row) { this._rows.Add(row); }
protected virtual void BeforeRowUpdate(ITableRow row) { }
private static void SetYapperColumnValues(Message message, ITableRow row) { PropertyInfo[] propertyInfoArray = message.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo propInfo in propertyInfoArray) { IEnumerable<Attribute> attrs = propInfo.GetCustomAttributes(); if (attrs == null) { continue; } IColumn column = null; bool isDbColumn = false; bool isInBlob = false; ; foreach (Attribute a in attrs) { if (a is YapperColumnAttribute && ((YapperColumnAttribute)a).ColumnLocation == ColumnLocation.Database) { isDbColumn = true; YapperColumnAttribute yapperColumn = a as YapperColumnAttribute; column = MessageTable.GetColumnFromName(yapperColumn.Name); } if (a is ProtoBuf.ProtoMemberAttribute) { isInBlob = true; } } if (column != null && isDbColumn && !isInBlob) { propInfo.SetValue(message, row.ColumnValues[column]); } } }
public void AddRowForInserting(ITableRow row) { this._rows.Add(row); }
public RowUpdateInput(string oldHash, ITableRow row) { this.Row = row; this.OldHash = oldHash; }
protected virtual void BeforeRowAdd(ITableRow row) { }