Пример #1
0
 internal void LogError(string backupid, string message, Exception ex)
 {
     lock (m_lock)
     {
         long id;
         if (!long.TryParse(backupid, out id))
         {
             id = -1;
         }
         ((System.Data.IDbDataParameter)m_errorcmd.Parameters[0]).Value = id;
         ((System.Data.IDbDataParameter)m_errorcmd.Parameters[1]).Value = message;
         ((System.Data.IDbDataParameter)m_errorcmd.Parameters[2]).Value = ex == null ? null : ex.ToString();
         ((System.Data.IDbDataParameter)m_errorcmd.Parameters[3]).Value = NormalizeDateTimeToEpochSeconds(DateTime.UtcNow);
         m_errorcmd.ExecuteNonQuery();
     }
 }
Пример #2
0
        public void TestInitialize()
        {
            var db = new NLORMMSSQLDb(NLORMSSQLDbTest.masterdb);

            System.Data.IDbCommand cmd = db.GetDbConnection().CreateCommand();
            cmd.CommandText = @"CREATE DATABASE TestORM";
            try
            {
                db.Open();
                cmd.ExecuteNonQuery();
                db.Close();
            }
            finally
            {
            }
        }
Пример #3
0
        }     // End Sub InsertList

        public virtual void InsertList <T>(System.Data.IDbCommand cmdInsert
                                           , System.Collections.Generic.IEnumerable <T> listToInsert
                                           , callbackAddData_t <T> addDataCallback)
        {
            using (System.Data.Common.DbConnection conn = this.Connection)
            {
                if (conn.State != System.Data.ConnectionState.Open)
                {
                    conn.Open();
                }

                cmdInsert.Connection = conn;

                using (System.Data.Common.DbTransaction transact = conn.BeginTransaction())
                {
                    cmdInsert.Transaction = transact;

                    try
                    {
                        foreach (T thisItem in listToInsert)
                        {
                            addDataCallback(cmdInsert, thisItem);

                            if (cmdInsert.ExecuteNonQuery() != 1)
                            {
                                // handled as needed,
                                // but this snippet will throw an exception to force a rollback
                                throw new System.InvalidProgramException();
                            } // End if (cmdInsert.ExecuteNonQuery() != 1)
                        }     // Next thisObject
                        transact.Commit();
                    }         // End Try
                    catch (System.Exception)
                    {
                        transact.Rollback();
                        throw;
                    } // End Catch
                    finally
                    {
                        if (conn.State != System.Data.ConnectionState.Closed)
                        {
                            conn.Close();
                        }
                    } // End Finally
                }     // End Using transact
            }         // End Using conn
        }             // End Sub InsertList
Пример #4
0
        /// <summary>
        /// 更新多个对象
        /// </summary>
        /// <param name="Objects">对象列表</param>
        /// <returns>更新修改的数据库记录个数</returns>
        public int UpdateObjects(System.Collections.IEnumerable Objects)
        {
            if (Objects == null)
            {
                throw new ArgumentNullException("Objects");
            }
            this.CheckBindInfo(Objects, true);
            this.CheckConnetion();
            int RecordCount = 0;

            using (System.Data.IDbCommand cmd = myConnection.CreateCommand())
            {
                foreach (object obj in Objects)
                {
                    TableBindInfo table = this.GetBindInfo(obj.GetType());
                    // 拼凑生成SQL更新语句
                    System.Collections.ArrayList values = new System.Collections.ArrayList();
                    System.Text.StringBuilder    myStr  = new System.Text.StringBuilder();
                    foreach (FieldBindInfo field in table.Fields)
                    {
                        object v = field.Property.GetValue(obj, null);
                        if (myStr.Length > 0)
                        {
                            myStr.Append(" , " + System.Environment.NewLine);
                        }
                        myStr.Append(FixFieldName(field.FieldName) + " = ? ");
                        values.Add(field.ToDataBase(v));
                    }
                    myStr.Insert(0, "Update " + FixTableName(table.TableName) + " Set ");
                    string strSQL = BuildCondition(obj, values);
                    myStr.Append(" Where " + strSQL);
                    strSQL = myStr.ToString();
                    // 设置SQL命令对象,填充参数
                    cmd.Parameters.Clear();
                    cmd.CommandText = strSQL;
                    foreach (object v in values)
                    {
                        System.Data.IDbDataParameter p = cmd.CreateParameter();
                        cmd.Parameters.Add(p);
                        p.Value = v;
                    }

                    RecordCount += cmd.ExecuteNonQuery();
                }        //foreach
            }            //using
            return(RecordCount);
        }
Пример #5
0
        public Boolean BlobWrite(String tableName, String columnName, String criteria, System.IO.Stream dataStream)
        {
            Boolean success = false;

            String updateStatement = "UPDATE " + tableName + " SET " + columnName + " = @blobData WHERE " + criteria;

            System.Data.IDbCommand updateCommand = null;

            System.IO.MemoryStream blobStream = new System.IO.MemoryStream();


            dataStream.Seek(0, System.IO.SeekOrigin.Begin);

            dataStream.CopyTo(blobStream);


            try {
                OnDemandOpen();

                updateCommand = CreateCommand(updateStatement);

                System.Data.SqlClient.SqlParameter blobParameter = new System.Data.SqlClient.SqlParameter("@blobData", System.Data.SqlDbType.VarBinary, Convert.ToInt32(blobStream.Length),

                                                                                                          System.Data.ParameterDirection.Input, true, 0, 0, null, System.Data.DataRowVersion.Current, blobStream.ToArray());

                updateCommand.Parameters.Add(blobParameter);

                success = (updateCommand.ExecuteNonQuery() == 1);
            }

            catch (Exception sqlException) {
                SetLastException(sqlException);
            }

            finally {
                if (updateCommand != null)
                {
                    updateCommand.Dispose();
                }                                                        // end if

                updateCommand = null;

                OnDemandClose();
            }

            return(success);
        }
Пример #6
0
        public long AddBlockset(string fullhash, long size, IEnumerable <string> blocklisthashes, long expectedblocklisthashes, System.Data.IDbTransaction transaction)
        {
            m_findBlocksetCommand.Transaction = transaction;
            m_findBlocksetCommand.SetParameterValue(0, size);
            m_findBlocksetCommand.SetParameterValue(1, fullhash);
            var blocksetid = m_findBlocksetCommand.ExecuteScalarInt64(-1);

            if (blocksetid != -1)
            {
                return(blocksetid);
            }

            m_insertBlocksetCommand.Transaction = transaction;
            m_insertBlocksetCommand.SetParameterValue(0, size);
            m_insertBlocksetCommand.SetParameterValue(1, fullhash);
            blocksetid = m_insertBlocksetCommand.ExecuteScalarInt64(-1);

            long c = 0;

            if (blocklisthashes != null)
            {
                var index = 0L;
                m_insertBlocklistHashCommand.Transaction = transaction;
                m_insertBlocklistHashCommand.SetParameterValue(0, blocksetid);

                foreach (var hash in blocklisthashes)
                {
                    if (!string.IsNullOrEmpty(hash))
                    {
                        c++;
                        if (c <= expectedblocklisthashes)
                        {
                            m_insertBlocklistHashCommand.SetParameterValue(1, index++);
                            m_insertBlocklistHashCommand.SetParameterValue(2, hash);
                            m_insertBlocklistHashCommand.ExecuteNonQuery();
                        }
                    }
                }
            }

            if (c != expectedblocklisthashes)
            {
                Logging.Log.WriteWarningMessage(LOGTAG, "MismatchInBlocklistHashCount", null, "Mismatching number of blocklist hashes detected on blockset {2}. Expected {0} blocklist hashes, but found {1}", expectedblocklisthashes, c, blocksetid);
            }

            return(blocksetid);
        }
Пример #7
0
        public override Int32 Execute()
        {
            Int32 rowCount = 0;



            System.Data.IDbCommand sqlCommand = application.EnvironmentDatabase.CreateCommand("dal.DataExplorerNodeEvaluation_MemberEnrollment_Execute");

            sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;


            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@nodeInstanceId", NodeInstanceId);

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@insurerId", InsurerId);

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@programId", ProgramId);

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@benefitPlanId", BenefitPlanId);

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@continuousEnrollment", ContinuousEnrollment);

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@continuousAllowedGaps", ContinuousAllowedGaps);

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@continuousAllowedGapDays", ContinuousAllowedGapDays);

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@startDate", dateCriteria.CalculateStartDate());

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@endDate", dateCriteria.CalculateEndDate());


            // RETURNED ROWS AFFECTED

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@rowCount", ((Int32)0));

            ((System.Data.IDbDataParameter)sqlCommand.Parameters["@rowCount"]).Direction = System.Data.ParameterDirection.Output;


            sqlCommand.CommandTimeout = 0;

            sqlCommand.ExecuteNonQuery();

            rowCount = Convert.ToInt32(((System.Data.IDbDataParameter)sqlCommand.Parameters["@rowCount"]).Value);


            return(rowCount);
        }
Пример #8
0
     protected override void ExecuteCommand(System.Data.IDbCommand command)
     {
         string[] separateActions = null;
         if (command.CommandText.Contains(CommandDelimiter))
         {
             separateActions = command.CommandText.Split(new string[] { CommandDelimiter }, StringSplitOptions.RemoveEmptyEntries);
         }
         else
         {
             separateActions = new string[] { command.CommandText }
         };
         foreach (string commandText in separateActions)
         {
             command.CommandText = commandText;
             command.ExecuteNonQuery();
         }
     }
 }
Пример #9
0
 private void CreateBySQL(Sybase.Persistence.ConnectionWrapper _conn, string sql, YPF.Comercial.RRCC.SUP.intrnl.SISSubscription __theObject)
 {
     System.Data.IDbCommand ps = com.sybase.afx.db.CommandUtil.CreateCommand(_conn, sql);
     com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), ps, "deviceId", __theObject.DeviceId);
     com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), ps, "username", __theObject.Username);
     com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), ps, "appname", __theObject.Appname);
     com.sybase.afx.db.CommandUtil.SetBoolean(_conn.GetConnectionProfile(), ps, "enable", __theObject.Enable);
     com.sybase.afx.db.CommandUtil.SetBoolean(_conn.GetConnectionProfile(), ps, "adminLock", __theObject.AdminLock);
     com.sybase.afx.db.CommandUtil.SetInt(_conn.GetConnectionProfile(), ps, "interval", __theObject.Interval);
     com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), ps, "protocol", __theObject.Protocol);
     com.sybase.afx.db.CommandUtil.SetNullableString(_conn.GetConnectionProfile(), ps, "address", __theObject.Address);
     com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), ps, "domain", __theObject.Domain);
     com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), ps, "package", __theObject.Package);
     com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), ps, "syncGroup", __theObject.SyncGroup);
     com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), ps, "clientId", __theObject.ClientId);
     ps.ExecuteNonQuery();
     ps.Dispose();;
 }
Пример #10
0
 /// <summary>
 /// Delete all the change logs .
 /// </summary>
 public static void DeleteChangeLogs()
 {
     try
     {
         string sql = "truncate table crmmobiledesa_1_0_changelogimpl";
         Sybase.Persistence.ConnectionWrapper _conn = YPF.Comercial.RRCC.SUP.CRMMobileDesaDB.AcquireDBWriteConnection();
         System.Data.IDbCommand ps = com.sybase.afx.db.CommandUtil.CreateCommand(_conn, sql);
         ps.ExecuteNonQuery();
     }
     catch (System.Data.DataException ex)
     {
         throw new Sybase.Persistence.PersistenceException(ex.ToString(), ex);
     }
     finally
     {
         YPF.Comercial.RRCC.SUP.CRMMobileDesaDB.ReleaseDBConnection();
     }
 }
Пример #11
0
        public static int ExecuteNonQuery(this System.Data.IDbCommand self, bool writeLog, string cmd, params object[] values)
        {
            if (cmd != null)
            {
                self.CommandText = cmd;
            }

            if (values != null && values.Length > 0)
            {
                self.Parameters.Clear();
                foreach (var n in values)
                {
                    self.AddParameter(n);
                }
            }

            using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteNonQuery", string.Format("ExecuteNonQuery: {0}", self.GetPrintableCommandText())) : null)
                return(self.ExecuteNonQuery());
        }
Пример #12
0
        public static int ExecuteNonQuery(this System.Data.IDbCommand self, string cmd, params object[] values)
        {
            if (cmd != null)
            {
                self.CommandText = cmd;
            }

            if (values != null && values.Length > 0)
            {
                self.Parameters.Clear();
                foreach (var n in values)
                {
                    self.AddParameter(n);
                }
            }

            using (new Logging.Timer(LC.L("ExecuteNonQuery: {0}", self.CommandText)))
                return(self.ExecuteNonQuery());
        }
Пример #13
0
        /// <summary>
        /// 创建 SQL Server 数据库。
        /// </summary>
        /// <param name="instanceName">数据库实例名。</param>
        /// <param name="loginSecure">是否使用 Windows 身份验证登录。</param>
        /// <param name="username">使用 SQL Server 身份验证时所使用的登录帐号。</param>
        /// <param name="password">使用 SQL Server 身份验证时所使用的密码。</param>
        /// <param name="databaseName">欲创建数据库的数据库名。</param>
        /// <param name="filePath">指定数据库文件路径。如传入 null 则使用默认路径。</param>
        /// <param name="dataFileSize">指定数据库的初始大小(MB)。</param>
        public static void CreateDatabase(string instanceName, bool loginSecure, string username, string password, string databaseName, string filePath, int dataFileSize)
        {
            SQLServerDb db = new SQLServerDb();

            db.InstanceName = instanceName;
            db.LoginSecure  = loginSecure;
            if (loginSecure == false)
            {
                db.UserName = username;
                db.Password = password;
            }
            db.DatabaseName = "master";

            System.Data.IDbConnection conn = db.GetDbConnection();
            conn.Open();

            System.Data.IDbCommand cmd = conn.CreateCommand();
            cmd.Connection = conn;

            string strSql;

            strSql = "CREATE DATABASE " + databaseName;

            if (filePath != null && filePath.Length > 0)
            {
                if (filePath.Substring(filePath.Length - 1).Equals("\\") == false)
                {
                    filePath += "\\";
                }
                strSql += " ON (NAME=" + databaseName + ",FILENAME='" + filePath + databaseName + ".mdf',";

                if (dataFileSize > 0)
                {
                    strSql += "SIZE=" + dataFileSize.ToString() + ",";
                }
                strSql += "FILEGROWTH=10%)";
            }
            cmd.CommandText = strSql;
            cmd.ExecuteNonQuery();

            conn.Close();
        }
Пример #14
0
        public void TestCleanup()
        {
            var db = new NLORMMSSQLDb(NLORMSSQLDbTest.masterdb);

            System.Data.IDbCommand cmd = db.GetDbConnection().CreateCommand();
            cmd.CommandText = @"DROP DATABASE TestORM";
            System.Data.IDbCommand closecmd = db.GetDbConnection().CreateCommand();
            closecmd.CommandText = @"alter database TestORM set single_user with rollback immediate";

            try
            {
                db.Open();
                closecmd.ExecuteNonQuery();
                cmd.ExecuteNonQuery();
                db.Close();
            }
            finally
            {
            }
        }
Пример #15
0
    protected override object EntityIsPersistent(SaveOrUpdateEvent @event)
    {
        Pony ent = @event.Entity as Pony;

        // I don't care if it's not a pony or if the entity doesn't need updating, call base!
        if (ent == null || !IsDirty(@event))
        {
            return(base.EntityIsPersistent(@event));
        }
        // Do nasty dialect-specific raw SQL because using NH to update this row throws us into an infinite loop
        string tablename = ((ILockable)@event.Entry.Persister).RootTableName.ToLower();

        System.Data.IDbCommand command = ((ISession)@event.Session).Connection.CreateCommand();
        command.CommandText = String.Format("update {0} set RevisionValidTo = {1} where Id = '{2}'", tablename, CurrentRevision.Id, ent.Id);
        command.ExecuteNonQuery();
        // Make the event look like it was never persistent and force a transient insert of the entity
        ent.Id       = Guid.Empty;
        @event.Entry = null;
        return(EntityIsTransient(@event));
    }
Пример #16
0
        public void UpdateRemoteVolume(string name, RemoteVolumeState state, long size, string hash, System.Data.IDbTransaction transaction = null)
        {
            m_updateremotevolumeCommand.Transaction = transaction;
            m_updateremotevolumeCommand.SetParameterValue(0, m_operationid);
            m_updateremotevolumeCommand.SetParameterValue(1, state.ToString());
            m_updateremotevolumeCommand.SetParameterValue(2, hash);
            m_updateremotevolumeCommand.SetParameterValue(3, size);
            m_updateremotevolumeCommand.SetParameterValue(4, name);
            var c = m_updateremotevolumeCommand.ExecuteNonQuery();

            if (c != 1)
            {
                throw new Exception("Unexpected number of remote volumes detected!");
            }

            if (state == RemoteVolumeState.Deleted)
            {
                RemoveRemoteVolume(name, transaction);
            }
        }
Пример #17
0
        public static void ExecuteNonQuery(System.Data.IDbCommand cmd)
        {
            using (System.Data.IDbConnection idbConn = GetConnection())
            {
                cmd.Connection = idbConn;

                try
                {
                    if (idbConn.State != System.Data.ConnectionState.Open)
                    {
                        idbConn.Open();
                    }

                    cmd.ExecuteNonQuery();
                }
                catch
                {
                    throw;
                }
            }
        }
Пример #18
0
        } //ExecuteQuery(string sql)

        /// <summary>
        /// 执行Sql语句
        /// </summary>
        /// <param name="sql">Sql语句</param>
        /// <param name="Conn">数据库连接对象</param>
        /// <returns>返回受影响行数</returns>
        public static int Execute(string sql, System.Data.Common.DbConnection Conn)
        {
            if (Conn == null)
            {
                Dbhelper.ErrLog("Dbhelper.Execute(string sql, System.Data.Common.DbConnection Conn):连接对象为空!");
                return(0);
            }
            System.Data.IDbCommand cmd = Conn.CreateCommand();

            cmd.CommandText = sql;
            try
            {
                return(cmd.ExecuteNonQuery());
            }
            catch (Exception ex)
            {
                Dbhelper.ErrLog("Dbhelper.ExecuteQuery(string sql, System.Data.Common.DbConnection Conn):" + ex.Message +
                                "/nsql=" + sql);
                return(0);
            }
        } //Execute(string sql)
Пример #19
0
        public bool UpdateBlockset(string hash, IEnumerable <string> blocklisthashes, System.Data.IDbTransaction transaction)
        {
            if (m_blockListHashLookup != null)
            {
                bool b;
                if (m_blockListHashLookup.TryGet(hash, -1, out b))
                {
                    return(false);
                }
            }
            else
            {
                m_findblocklisthashCommand.Transaction = transaction;
                m_findblocklisthashCommand.SetParameterValue(0, hash);
                var r = m_findblocklisthashCommand.ExecuteScalar();
                if (r != null && r != DBNull.Value)
                {
                    return(false);
                }
            }

            if (m_blockListHashLookup != null)
            {
                m_blockListHashLookup.Add(hash, -1, false);
            }

            m_insertBlockset.Transaction = transaction;
            m_insertBlockset.SetParameterValue(0, hash);

            var index = 0L;

            foreach (var s in blocklisthashes)
            {
                m_insertBlockset.SetParameterValue(1, s);
                m_insertBlockset.SetParameterValue(2, index++);
                m_insertBlockset.ExecuteNonQuery();
            }

            return(true);
        }
Пример #20
0
        public override Int32 Execute()
        {
            Int32 rowCount = 0;



            System.Data.IDbCommand sqlCommand = application.EnvironmentDatabase.CreateCommand("dal.DataExplorerNodeEvaluation_PopulationMembership_Execute");

            sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;


            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@nodeInstanceId", NodeInstanceId);


            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@populationId", ((populationEvaluationType == Enumerations.DataExplorerNodeEvaluationPopulationEvaluationType.Population) ? populationId : 0));

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@populationTypeId", ((populationEvaluationType == Enumerations.DataExplorerNodeEvaluationPopulationEvaluationType.PopulationType) ? populationTypeId : 0));

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@startDate", dateCriteria.CalculateStartDate());

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@endDate", dateCriteria.CalculateEndDate());


            // RETURNED ROWS AFFECTED

            application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@rowCount", ((Int32)0));

            ((System.Data.IDbDataParameter)sqlCommand.Parameters["@rowCount"]).Direction = System.Data.ParameterDirection.Output;


            sqlCommand.CommandTimeout = 0;

            sqlCommand.ExecuteNonQuery();

            rowCount = Convert.ToInt32(((System.Data.IDbDataParameter)sqlCommand.Parameters["@rowCount"]).Value);


            return(rowCount);
        }
Пример #21
0
 /// <summary>
 /// Delete the mobile business object.
 /// </summary>
 public void Delete()
 {
     Sybase.Persistence.ConnectionWrapper _conn = YPF.Comercial.RRCC.SUP.CRMMobileDesaDB.AcquireDBWriteConnection();
     try
     {
         int count = 1;
         System.Data.IDbCommand ps1 = com.sybase.afx.db.CommandUtil.CreateCommand(_conn, "delete co_crmmobiledesa_1_0_clientpersonalization where \"id\"=?");
         com.sybase.afx.db.CommandUtil.SetLong(_conn.GetConnectionProfile(), ps1, "id", this.Id);
         count = ps1.ExecuteNonQuery();
         ps1.Dispose();;
         _isNew     = false;
         _isDeleted = true;
     }
     catch (System.Data.DataException ex)
     {
         throw new Sybase.Persistence.PersistenceException(ex.ToString(), ex);
     }
     finally
     {
         YPF.Comercial.RRCC.SUP.CRMMobileDesaDB.ReleaseDBConnection();
     }
 }
Пример #22
0
 /// <summary>
 /// Delete the mobile business object.
 /// </summary>
 public void Delete()
 {
     Sybase.Persistence.ConnectionWrapper _conn = YPF.Comercial.RRCC.SUP.CRMMobileDesaDB.AcquireDBWriteConnection();
     try
     {
         int count = 1;
         System.Data.IDbCommand ps1 = com.sybase.afx.db.CommandUtil.CreateCommand(_conn, "delete crmmobiledesa_1_0_changelogimpl where \"a\"=? and \"b\"=?");
         com.sybase.afx.db.CommandUtil.SetInt(_conn.GetConnectionProfile(), ps1, "entityType", this.EntityType);
         com.sybase.afx.db.CommandUtil.SetLong(_conn.GetConnectionProfile(), ps1, "surrogateKey", this.SurrogateKey);
         count = ps1.ExecuteNonQuery();
         ps1.Dispose();;
         _isNew     = false;
         _isDeleted = true;
     }
     catch (System.Data.DataException ex)
     {
         throw new Sybase.Persistence.PersistenceException(ex.ToString(), ex);
     }
     finally
     {
         YPF.Comercial.RRCC.SUP.CRMMobileDesaDB.ReleaseDBConnection();
     }
 }
Пример #23
0
 /// <summary>
 /// Update the mobile business object
 /// </summary>
 public void Update()
 {
     Sybase.Persistence.ConnectionWrapper _conn = YPF.Comercial.RRCC.SUP.CRMMobileDesaDB.AcquireDBWriteConnection();
     try
     {
         int count = 1;
         System.Data.IDbCommand cmd = com.sybase.afx.db.CommandUtil.CreateCommand(_conn, "update co_crmmobiledesa_1_0_offlineauthentication set \"b\"=? where \"a\"=?");
         com.sybase.afx.db.CommandUtil.SetInt(_conn.GetConnectionProfile(), cmd, "passwordHash", this.PasswordHash);
         com.sybase.afx.db.CommandUtil.SetString(_conn.GetConnectionProfile(), cmd, "user", this.User);
         count = cmd.ExecuteNonQuery();
         cmd.Dispose();;
         _isNew     = false;
         _isDirty   = false;
         _isDeleted = false;
     }
     catch (System.Data.DataException ex)
     {
         throw new Sybase.Persistence.PersistenceException(ex.ToString(), ex);
     }
     finally
     {
         YPF.Comercial.RRCC.SUP.CRMMobileDesaDB.ReleaseDBConnection();
     }
 }
        virtual public Boolean Save(Mercury.Server.Application application)
        {
            Boolean success = false;


            try {
                application.EnvironmentDatabase.BeginTransaction();



                System.Data.IDbCommand sqlCommand = application.EnvironmentDatabase.CreateCommand("MemberAuthorizedServiceDetail_InsertUpdate");

                sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;


                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@memberAuthorizedServiceId", memberAuthorizedServiceId);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@authorizedServiceDefinitionId", authorizedServiceDefinitionId);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@eventDate", eventDate);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@authorizationId", authorizationId);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@authorizationNumber", authorizationNumber, Server.Data.DataTypeConstants.UniqueId);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@externalAuthorizationId", externalAuthorizationId, Server.Data.DataTypeConstants.UniqueId);



                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@authorizationLine", authorizationLine);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@memberId", memberId);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@referringProviderId", referringProviderId);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@serviceProviderId", serviceProviderId);


                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@category", authorizationCategory, Server.Data.DataTypeConstants.TypeName);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@subcategory", authorizationSubcategory, Server.Data.DataTypeConstants.TypeName);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@serviceType", authorizationServiceType, Server.Data.DataTypeConstants.TypeName);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@status", authorizationStatus, Server.Data.DataTypeConstants.TypeName);



                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@receivedDate", receivedDate);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@referralDate", referralDate);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@effectiveDate", effectiveDate);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@terminationDate", terminationDate);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@serviceDate", serviceDate);


                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@principalDiagnosisCode", principalDiagnosisCode, Server.Data.DataTypeConstants.DiagnosisCode);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@principalDiagnosisVersion", principalDiagnosisVersion);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@diagnosisCode", diagnosisCode, Server.Data.DataTypeConstants.DiagnosisCode);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@diagnosisVersion", diagnosisVersion);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@revenueCode", revenueCode, Server.Data.DataTypeConstants.RevenueCode);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@procedureCode", procedureCode, Server.Data.DataTypeConstants.ProcedureCode);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@modifierCode", modifierCode, Server.Data.DataTypeConstants.ModifierCode);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@specialtyName", specialtyName, Server.Data.DataTypeConstants.Name);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@ndcCode", ndcCode, Server.Data.DataTypeConstants.NdcCode);

                application.EnvironmentDatabase.AppendCommandParameter(sqlCommand, "@description", description, Server.Data.DataTypeConstants.Name);


                // DO NOT EVALUATE THE NUMBER OF ROWS AFFECTED BECAUSE THE CHECK FOR DUPLICATES

                // IS HANDLED IN THE STORED PROCEDURE, AND THUS COULD RETURN 0 OR 1

                sqlCommand.ExecuteNonQuery();

                success = true;



                #region Old Method

                //sqlStatement = new StringBuilder ();

                //sqlStatement.Append ("EXEC dbo.MemberAuthorizedServiceDetail_InsertUpdate ");

                //sqlStatement.Append (memberAuthorizedServiceId.ToString () + ", ");

                //sqlStatement.Append (authorizedServiceDefinitionId.ToString () + ", ");

                //sqlStatement.Append ("'" + eventDate.ToString ("MM/dd/yyyy") + "', ");

                //sqlStatement.Append (authorizationId.ToString () + ", ");

                //sqlStatement.Append ("'" + authorizationNumber.Replace ("'", "''") + "', ");

                //sqlStatement.Append ("'" + externalAuthorizationId.Replace ("'", "''") + "', ");

                //sqlStatement.Append (authorizationLine.ToString () + ", ");

                //sqlStatement.Append (memberId.ToString () + ", ");

                //sqlStatement.Append (referringProviderId.ToString () + ", ");

                //sqlStatement.Append (serviceProviderId.ToString () + ", ");

                //sqlStatement.Append ("'" + authorizationCategory.Replace ("'", "''") + "', ");

                //sqlStatement.Append ("'" + authorizationSubcategory.Replace ("'", "''") + "', ");

                //sqlStatement.Append ("'" + authorizationServiceType.Replace ("'", "''") + "', ");

                //sqlStatement.Append ("'" + authorizationStatus + "', ");

                //if (receivedDate.HasValue) { sqlStatement.Append ("'" + receivedDate.Value.ToString ("MM/dd/yyyy") + "', "); } else { sqlStatement.Append ("NULL, "); }

                //if (referralDate.HasValue) { sqlStatement.Append ("'" + referralDate.Value.ToString ("MM/dd/yyyy") + "', "); } else { sqlStatement.Append ("NULL, "); }

                //sqlStatement.Append ("'" + effectiveDate.ToString ("MM/dd/yyyy") + "', ");

                //sqlStatement.Append ("'" + terminationDate.ToString ("MM/dd/yyyy") + "', ");

                //if (serviceDate.HasValue) { sqlStatement.Append ("'" + serviceDate.Value.ToString ("MM/dd/yyyy") + "', "); } else { sqlStatement.Append ("NULL, "); }


                //sqlStatement.Append ("'" + principalDiagnosisCode + "', ");

                //sqlStatement.Append (principalDiagnosisVersion.ToString () + ", ");

                //sqlStatement.Append ("'" + diagnosisCode + "', ");

                //sqlStatement.Append (diagnosisVersion.ToString () + ", ");

                //sqlStatement.Append ("'" + revenueCode + "', ");

                //sqlStatement.Append ("'" + procedureCode + "', ");

                //sqlStatement.Append ("'" + modifierCode + "',");

                //sqlStatement.Append ("'" + specialtyName + "',");

                //sqlStatement.Append ("'" + ndcCode + "', ");

                //sqlStatement.Append ("'" + description.Replace ("'", "''").Trim () + "' ");

                //success = application.EnvironmentDatabase.ExecuteSqlStatement (sqlStatement.ToString ());

                #endregion



                if (!success)
                {
                    application.SetLastException(application.EnvironmentDatabase.LastException);

                    throw application.EnvironmentDatabase.LastException;
                }

                success = true;

                application.EnvironmentDatabase.CommitTransaction();
            }

            catch (Exception applicationException) {
                application.EnvironmentDatabase.RollbackTransaction();

                application.SetLastException(applicationException);
            }

            return(success);
        }
Пример #25
0
        /// <summary>
        /// Adds a blockset to the database, returns a value indicating if the blockset is new
        /// </summary>
        /// <param name="filehash">The hash of the blockset</param>
        /// <param name="size">The size of the blockset</param>
        /// <param name="fragmentoffset">The fragmentoffset for the last block</param>
        /// <param name="fragmenthash">The hash of the fragment</param>
        /// <param name="hashes">The list of hashes</param>
        /// <param name="blocksetid">The id of the blockset, new or old</param>
        /// <returns>True if the blockset was created, false otherwise</returns>
        public bool AddBlockset(string filehash, long size, int blocksize, IEnumerable <string> hashes, IEnumerable <string> blocklistHashes, out long blocksetid, System.Data.IDbTransaction transaction = null)
        {
            m_findblocksetCommand.Transaction = transaction;
            blocksetid = m_findblocksetCommand.ExecuteScalarInt64(null, -1, filehash, size);
            if (blocksetid != -1)
            {
                return(false); //Found it
            }
            using (var tr = new TemporaryTransactionWrapper(m_connection, transaction))
            {
                m_insertblocksetCommand.Transaction = tr.Parent;
                m_insertblocksetCommand.SetParameterValue(0, size);
                m_insertblocksetCommand.SetParameterValue(1, filehash);
                blocksetid = m_insertblocksetCommand.ExecuteScalarInt64();

                long ix = 0;
                if (blocklistHashes != null)
                {
                    m_insertblocklistHashesCommand.SetParameterValue(0, blocksetid);
                    m_insertblocklistHashesCommand.Transaction = tr.Parent;
                    foreach (var bh in blocklistHashes)
                    {
                        m_insertblocklistHashesCommand.SetParameterValue(1, ix);
                        m_insertblocklistHashesCommand.SetParameterValue(2, bh);
                        m_insertblocklistHashesCommand.ExecuteNonQuery();
                        ix++;
                    }
                }

                m_insertblocksetentryCommand.SetParameterValue(0, blocksetid);
                m_insertblocksetentryCommand.Transaction = tr.Parent;

                m_insertblocksetentryFastCommand.SetParameterValue(0, blocksetid);
                m_insertblocksetentryFastCommand.Transaction = tr.Parent;

                ix = 0;
                long remainsize = size;
                foreach (var h in hashes)
                {
                    var exsize = remainsize < blocksize ? remainsize : blocksize;
                    m_insertblocksetentryCommand.SetParameterValue(1, ix);
                    m_insertblocksetentryCommand.SetParameterValue(2, h);
                    m_insertblocksetentryCommand.SetParameterValue(3, exsize);
                    var c = m_insertblocksetentryCommand.ExecuteNonQuery();
                    if (c != 1)
                    {
                        m_result.AddError(string.Format("Checking errors, related to #1400. Unexpected result count: {0}, expected {1}, hash: {2}, size: {3}, blocksetid: {4}, ix: {5}, fullhash: {6}, fullsize: {7}", c, 1, h, exsize, blocksetid, ix, filehash, size), null);
                        using (var cmd = m_connection.CreateCommand(tr.Parent))
                        {
                            var bid = cmd.ExecuteScalarInt64(@"SELECT ""ID"" FROM ""Block"" WHERE ""Hash"" = ?", -1, h);
                            if (bid == -1)
                            {
                                throw new Exception(string.Format("Could not find any blocks with the given hash: {0}", h));
                            }
                            foreach (var rd in cmd.ExecuteReaderEnumerable(@"SELECT ""Size"" FROM ""Block"" WHERE ""Hash"" = ?", h))
                            {
                                m_result.AddError(string.Format("Found block with ID {0} and hash {1} and size {2}", bid, h, rd.ConvertValueToInt64(0, -1)), null);
                            }
                        }

                        throw new Exception(string.Format("Unexpected result count: {0}, expected {1}, check log for more messages", c, 1));
                    }

                    ix++;
                    remainsize -= blocksize;
                }

                tr.Commit();
            }

            return(true);
        }
Пример #26
0
 public BlockMarker(System.Data.IDbConnection connection, string blocktablename, string filetablename)
 {
     m_insertblockCommand = connection.CreateCommand();
     m_resetfileCommand  = connection.CreateCommand();
     m_updateAsRestoredCommand = connection.CreateCommand();
     m_statUpdateCommand = connection.CreateCommand();
     
     m_insertblockCommand.Transaction = connection.BeginTransaction();
     m_resetfileCommand.Transaction = m_insertblockCommand.Transaction;
     m_updateAsRestoredCommand.Transaction = m_insertblockCommand.Transaction;
     m_statUpdateCommand.Transaction = m_insertblockCommand.Transaction;
     
     m_blocktablename = blocktablename;
     m_updateTable = "UpdatedBlocks-" + Library.Utility.Utility.ByteArrayAsHexString(Guid.NewGuid().ToByteArray());
     
     m_insertblockCommand.ExecuteNonQuery(string.Format(@"CREATE TEMPORARY TABLE ""{0}"" (""FileID"" INTEGER NOT NULL, ""Index"" INTEGER NOT NULL, ""Hash"" TEXT NOT NULL, ""Size"" INTEGER NOT NULL)", m_updateTable));
     m_insertblockCommand.CommandText = string.Format(@"INSERT INTO ""{0}"" (""FileID"", ""Index"", ""Hash"", ""Size"") VALUES (?, ?, ?, ?) ", m_updateTable);
     m_insertblockCommand.AddParameters(4);
                     
     m_resetfileCommand.CommandText = string.Format(@"DELETE FROM ""{0}"" WHERE ""FileID"" = ?", m_updateTable);
     m_resetfileCommand.AddParameters(1);
     
     m_updateAsRestoredCommand.CommandText = string.Format(@"INSERT INTO ""{0}"" (""FileID"", ""Index"", ""Hash"", ""Size"") SELECT ""FileID"", ""Index"", ""Hash"", ""Size"" FROM ""{1}"" WHERE ""{1}"".""FileID"" = ?", m_updateTable, m_blocktablename);
     m_updateAsRestoredCommand.AddParameters(1);
     
     m_statUpdateCommand.CommandText = string.Format(@"SELECT COUNT(DISTINCT ""FileID""), SUM(""Size"") FROM ""{0}"" WHERE ""Restored"" = 1 OR ""ID"" IN (SELECT ""{0}"".""ID"" FROM ""{0}"", ""{1}"" WHERE ""{0}"".""FileID"" = ""{1}"".""FileID"" AND ""{0}"".""Index"" = ""{1}"".""Index"" AND ""{0}"".""Hash"" = ""{1}"".""Hash"" AND ""{0}"".""Size"" = ""{1}"".""Size"" )", m_blocktablename, m_updateTable);
 }
Пример #27
0
        public long AddBlockset(string fullhash, long size, IEnumerable <string> blocklisthashes, long expectedblocklisthashes, System.Data.IDbTransaction transaction)
        {
            var blocksetid = -1L;

            if (m_fileHashLookup != null)
            {
                if (m_fileHashLookup.TryGet(fullhash, size, out blocksetid))
                {
                    return(blocksetid);
                }
                else
                {
                    blocksetid = -1;
                }
            }
            else
            {
                m_findBlocksetCommand.Transaction = transaction;
                m_findBlocksetCommand.SetParameterValue(0, size);
                m_findBlocksetCommand.SetParameterValue(1, fullhash);
                blocksetid = m_findBlocksetCommand.ExecuteScalarInt64(-1);
                if (blocksetid != -1)
                {
                    return(blocksetid);
                }
            }

            m_insertBlocksetCommand.Transaction = transaction;
            m_insertBlocksetCommand.SetParameterValue(0, size);
            m_insertBlocksetCommand.SetParameterValue(1, fullhash);
            blocksetid = m_insertBlocksetCommand.ExecuteScalarInt64(-1);

            if (m_fileHashLookup != null)
            {
                m_fileHashLookup.Add(fullhash, size, blocksetid);
            }

            if (blocklisthashes != null)
            {
                var index = 0L;
                m_insertBlocklistHashCommand.Transaction = transaction;
                m_insertBlocklistHashCommand.SetParameterValue(0, blocksetid);

                long c = 0;
                foreach (var hash in blocklisthashes)
                {
                    if (!string.IsNullOrEmpty(hash))
                    {
                        c++;
                        if (c <= expectedblocklisthashes)
                        {
                            m_insertBlocklistHashCommand.SetParameterValue(1, index++);
                            m_insertBlocklistHashCommand.SetParameterValue(2, hash);
                            m_insertBlocklistHashCommand.ExecuteNonQuery();
                        }
                    }
                }

                if (c > expectedblocklisthashes)
                {
                    m_result.AddWarning(string.Format("Extra blocklist hashes detected on blockset {2}. Expected {0} blocklist hashes, but found {1}", expectedblocklisthashes, c, blocksetid), null);
                }
            }

            return(blocksetid);
        }
        public override Boolean Save () {

            Boolean success = false;

            StringBuilder sqlStatement = new StringBuilder ();

            String childIds = String.Empty;


            try {

                Dictionary<String, String> validationResponse = Validate ();

                if (validationResponse.Count != 0) {

                    foreach (String validationKey in validationResponse.Keys) {

                        throw new ApplicationException ("Invalid [" + validationKey + "]: " + validationResponse[validationKey]);

                    }

                }

                modifiedAccountInfo = new Mercury.Server.Data.AuthorityAccountStamp (application.Session);


                System.Data.IDbCommand sqlCommand = application.EnvironmentDatabase.CreateCommand ("MemberCaseCarePlanAssessmentCareMeasureComponent_InsertUpdate");

                sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;


                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@memberCaseCarePlanAssessmentCareMeasureComponentId", Id);

                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@memberCaseCarePlanAssessmentCareMeasureId", MemberCaseCarePlanAssessmentCareMeasureId);

                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@careMeasureComponentId", CareMeasureComponentId);

                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@careMeasureComponentName", Name, Server.Data.DataTypeConstants.Description99);

                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@careMeasureScaleId", CareMeasureScaleId);

                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@tag", Tag, Server.Data.DataTypeConstants.UniqueId);

                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@componentValue", ComponentValue);



                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@modifiedAuthorityName", ModifiedAccountInfo.SecurityAuthorityName, Server.Data.DataTypeConstants.Name);

                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@modifiedAccountId", ModifiedAccountInfo.UserAccountId, Server.Data.DataTypeConstants.UserAccountId);

                application.EnvironmentDatabase.AppendCommandParameter (sqlCommand, "@modifiedAccountName", ModifiedAccountInfo.UserAccountName, Server.Data.DataTypeConstants.Name);


                success = (sqlCommand.ExecuteNonQuery () > 0);


                if (!success) {

                    application.SetLastException (application.EnvironmentDatabase.LastException);

                    throw application.EnvironmentDatabase.LastException;

                }

                SetIdentity ();

                if (!success) {

                    application.SetLastException (application.EnvironmentDatabase.LastException);

                    throw application.EnvironmentDatabase.LastException;

                }

                success = true;

            }

            catch (Exception applicationException) {

                success = false;

                application.SetLastException (applicationException);

            }

            return success;

        }
Пример #29
0
        public void UpdateBlock(string hash, long size, long volumeID, System.Data.IDbTransaction transaction)
        {
            var currentVolumeId = -2L;

            if (m_blockHashLookup != null)
            {
                if (!m_blockHashLookup.TryGet(hash, size, out currentVolumeId))
                {
                    currentVolumeId = -2;
                }
            }
            else
            {
                m_findHashBlockCommand.Transaction = transaction;
                m_findHashBlockCommand.SetParameterValue(0, hash);
                m_findHashBlockCommand.SetParameterValue(1, size);
                var r = m_findHashBlockCommand.ExecuteScalar();
                if (r != null && r != DBNull.Value)
                {
                    currentVolumeId = Convert.ToInt64(r);
                }
            }

            if (currentVolumeId == volumeID)
            {
                return;
            }

            if (currentVolumeId == -2)
            {
                //Insert
                m_insertBlockCommand.Transaction = transaction;
                m_insertBlockCommand.SetParameterValue(0, hash);
                m_insertBlockCommand.SetParameterValue(1, size);
                m_insertBlockCommand.SetParameterValue(2, volumeID);
                m_insertBlockCommand.ExecuteNonQuery();

                if (m_blockHashLookup != null)
                {
                    m_blockHashLookup.Add(hash, size, volumeID);
                }
            }
            else if (currentVolumeId == -1)
            {
                //Update
                m_updateBlockVolumeCommand.Transaction = transaction;
                m_updateBlockVolumeCommand.SetParameterValue(0, volumeID);
                m_updateBlockVolumeCommand.SetParameterValue(1, hash);
                m_updateBlockVolumeCommand.SetParameterValue(2, size);
                var c = m_updateBlockVolumeCommand.ExecuteNonQuery();
                if (c != 1)
                {
                    throw new Exception(string.Format("Failed to update table, found {0} entries for key {1} with size {2}", c, hash, size));
                }

                if (m_blockHashLookup != null)
                {
                    m_blockHashLookup.Add(hash, size, volumeID);
                }
            }
            else
            {
                m_insertDuplicateBlockCommand.Transaction = transaction;
                m_insertDuplicateBlockCommand.SetParameterValue(0, hash);
                m_insertDuplicateBlockCommand.SetParameterValue(1, size);
                m_insertDuplicateBlockCommand.SetParameterValue(2, volumeID);
                m_insertDuplicateBlockCommand.ExecuteNonQuery();
            }
        }
Пример #30
0
        public void createDB()
        {
            try
            {
                // Name, Path and password

                string           cs         = string.Format("Version=3,uri=file:{0}", @Settings.sqlFile());
                SqliteConnection connection = new SqliteConnection(cs);
                connection.Open();
                System.Data.IDbCommand encryption = connection.CreateCommand();
                encryption.CommandText = "pragma hexkey='" + Initialization.parametersFromBinary("sqlitePassword") + "'";
                encryption.ExecuteNonQuery();

                // Database structure

                String[] sql_structure = { "create table config (parameter varchar(50), value varchar(100))" };

                foreach (string element in sql_structure)
                {
                    SqliteCommand command = new SqliteCommand(element, connection);
                    command.ExecuteNonQuery();
                }

                // Population of config table

                SqliteCommand insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.TAFLAG + "', '" + Initialization.parametersFromBinary(Settings.TAFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.HEARTBEAT + "', '" + Initialization.parametersFromBinary(Settings.HEARTBEAT) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.UNIQUEGUID + "', '" + Settings.UNIQUEGUID_VALUE() + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.SRFLAG + "', '" + Initialization.parametersFromBinary(Settings.SRFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.ANFLAG + "', '" + Initialization.parametersFromBinary(Settings.ANFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.AESKEYFLAG + "', '" + Initialization.parametersFromBinary(Settings.AESKEYFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.AESIVFLAG + "', '" + Initialization.parametersFromBinary(Settings.AESIVFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.EXEFLAG + "', '" + Initialization.parametersFromBinary(Settings.EXEFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.SRPWDFLAG + "', '" + Initialization.parametersFromBinary(Settings.SRPWDFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.HVERFLAG + "', '" + Initialization.parametersFromBinary(Settings.HVERFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.APOSTFIXFLAG + "', '" + Initialization.parametersFromBinary(Settings.APOSTFIXFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.REGFLAG + "', '" + Initialization.parametersFromBinary(Settings.REGFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                insertSQL = new SqliteCommand("insert into config (parameter, value) VALUES ('" + Settings.TPORTFLAG + "', '" + Initialization.parametersFromBinary(Settings.TPORTFLAG) + "')", connection);
                insertSQL.ExecuteNonQuery();

                connection.Close();
            }
            catch { }
        }
Пример #31
0
        /// <summary>
        /// Adds a blockset to the database, returns a value indicating if the blockset is new
        /// </summary>
        /// <param name="filehash">The hash of the blockset</param>
        /// <param name="size">The size of the blockset</param>
        /// <param name="fragmentoffset">The fragmentoffset for the last block</param>
        /// <param name="fragmenthash">The hash of the fragment</param>
        /// <param name="hashes">The list of hashes</param>
        /// <param name="blocksetid">The id of the blockset, new or old</param>
        /// <returns>True if the blockset was created, false otherwise</returns>
        public bool AddBlockset(string filehash, long size, int blocksize, IEnumerable <string> hashes, IEnumerable <string> blocklistHashes, out long blocksetid, System.Data.IDbTransaction transaction = null)
        {
            object r = null;

            if (m_fileHashLookup != null)
            {
                if (m_fileHashLookup.TryGet(filehash, size, out blocksetid))
                {
                    return(false);
                }
            }
            else
            {
                m_findblocksetCommand.Transaction = transaction;
                r = m_findblocksetCommand.ExecuteScalar(null, filehash, size);
                if (r != null && r != DBNull.Value)
                {
                    blocksetid = Convert.ToInt64(r);
                    return(false); //Found it
                }
            }

            using (var tr = new TemporaryTransactionWrapper(m_connection, transaction))
            {
                m_insertblocksetCommand.Transaction = tr.Parent;
                m_insertblocksetCommand.SetParameterValue(0, size);
                m_insertblocksetCommand.SetParameterValue(1, filehash);
                blocksetid = Convert.ToInt64(m_insertblocksetCommand.ExecuteScalar());
                if (m_fileHashLookup != null)
                {
                    m_fileHashLookup.Add(filehash, size, blocksetid);
                }

                long ix = 0;
                if (blocklistHashes != null)
                {
                    m_insertblocklistHashesCommand.SetParameterValue(0, blocksetid);
                    m_insertblocklistHashesCommand.Transaction = tr.Parent;
                    foreach (var bh in blocklistHashes)
                    {
                        m_insertblocklistHashesCommand.SetParameterValue(1, ix);
                        m_insertblocklistHashesCommand.SetParameterValue(2, bh);
                        m_insertblocklistHashesCommand.ExecuteNonQuery();
                        ix++;
                    }
                }

                m_insertblocksetentryCommand.SetParameterValue(0, blocksetid);
                m_insertblocksetentryCommand.Transaction = tr.Parent;

                m_insertblocksetentryFastCommand.SetParameterValue(0, blocksetid);
                m_insertblocksetentryFastCommand.Transaction = tr.Parent;

                ix = 0;
                long remainsize = size;
                foreach (var h in hashes)
                {
                    var exsize = remainsize < blocksize ? remainsize : blocksize;
                    var found  = false;
                    if (m_blockHashLookup != null)
                    {
                        KeyValuePair <long, long> id;
                        if (m_blockHashLookup.TryGet(h, exsize, out id) && id.Value == exsize)
                        {
                            m_insertblocksetentryFastCommand.SetParameterValue(1, ix);
                            m_insertblocksetentryFastCommand.SetParameterValue(2, id.Key);
                            var cx = m_insertblocksetentryFastCommand.ExecuteNonQuery();
                            if (cx != 1)
                            {
                                throw new Exception(string.Format("Unexpected result count: {0}, expected {1}", cx, 1));
                            }
                            found = true;
                        }
                    }

                    if (!found)
                    {
                        m_insertblocksetentryCommand.SetParameterValue(1, ix);
                        m_insertblocksetentryCommand.SetParameterValue(2, h);
                        m_insertblocksetentryCommand.SetParameterValue(3, exsize);
                        var c = m_insertblocksetentryCommand.ExecuteNonQuery();
                        if (c != 1)
                        {
                            throw new Exception(string.Format("Unexpected result count: {0}, expected {1}", c, 1));
                        }
                    }

                    ix++;
                    remainsize -= blocksize;
                }

                tr.Commit();
            }

            return(true);
        }