protected override RowUpdatedEventArgs CreateRowUpdatedEvent(DataRow dataRow, IDbCommand command,
		                                                             StatementType statementType,
		                                                             DataTableMapping tableMapping)
		{
			NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "CreateRowUpdatedEvent");
			return new NpgsqlRowUpdatedEventArgs(dataRow, command, statementType, tableMapping);
		}

 protected override void ApplyParameterInfo(DbParameter parameter, DataRow datarow, StatementType statementType, bool whereClause)
 {
     SqlParameter parameter2 = (SqlParameter) parameter;
     object obj3 = datarow[SchemaTableColumn.ProviderType];
     parameter2.SqlDbType = (SqlDbType) obj3;
     parameter2.Offset = 0;
     if ((parameter2.SqlDbType == SqlDbType.Udt) && !parameter2.SourceColumnNullMapping)
     {
         parameter2.UdtTypeName = datarow["DataTypeName"] as string;
     }
     else
     {
         parameter2.UdtTypeName = string.Empty;
     }
     object obj2 = datarow[SchemaTableColumn.NumericPrecision];
     if (DBNull.Value != obj2)
     {
         byte num2 = (byte) ((short) obj2);
         parameter2.PrecisionInternal = (0xff != num2) ? num2 : ((byte) 0);
     }
     obj2 = datarow[SchemaTableColumn.NumericScale];
     if (DBNull.Value != obj2)
     {
         byte num = (byte) ((short) obj2);
         parameter2.ScaleInternal = (0xff != num) ? num : ((byte) 0);
     }
 }

 /// <summary>
 /// Initializes a new instance of the Statement class.
 /// </summary>
 /// <param name="proxy">Proxy object for the statement.</param>
 /// <param name="type">The type of the statement.</param>
 internal Statement(CodeUnitProxy proxy, StatementType type) 
     : base(proxy, (int)type)
 {
     Param.AssertNotNull(proxy, "proxy");
     Param.Ignore(type);
     CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(StatementType), this.StatementType), "The type is invalid.");
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="TaxRequest"/> class.
 /// </summary>
 /// <param name="docType">
 /// The doc Type. This determines if the quotation should be recorded or if it is just an estimate.
 /// Defaults to an estimate.
 /// </param>
 public TaxRequest(StatementType docType = StatementType.SalesOrder)
 {
     DocDate = DateTime.Today.ToString("yyyy-M-dddd");
     DetailLevel = DetailLevel.Tax;
     Commit = false;
     DocType = docType;
 }

 /// <summary>
 /// Resets content of this request.
 /// Used for pooling.
 /// </summary>
 public void Clear()
 {
     DbStatementType = 0;
     EntityName = null;
     FieldNames = null;
     InputItemsCount = 0;
 }

        private bool TryGetSimpleCaseStatementType(SwitchCase theCase, out StatementType statementType, out string gotoLabel)
        {
            gotoLabel = null;
            statementType = StatementType.None;
            if (theCase.Body.Statements.Count != 1 || !string.IsNullOrEmpty(theCase.Body.Statements[0].Label))
            {
                return false;
            }

            Statement statement = theCase.Body.Statements[0];
            if (statement is GotoStatement)
            {
                statementType = StatementType.Goto;
                gotoLabel = (statement as GotoStatement).TargetLabel;
            }
            else if (statement is BreakStatement)
            {
                statementType = StatementType.Break;
            }
            else if (statement is ContinueStatement)
            {
                statementType = StatementType.Continue;
            }

            return statementType != StatementType.None;
        }

        public void CreateStatement_ExpectValid()
        {
            //Arrange
            string localStatementIdString = "STMT01";
            StatementId localStatementId = new StatementId(localStatementIdString);

            SpecificFieldsFactory localfactory = new SpecificFieldsFactory();
            string[] listspecificfields = { "Credit Card", "12" };
            StatementType localStatementType = new StatementType(localfactory, "CreditCardProvider", listspecificfields);

            StatementSpecificFields localspecificfields = localStatementType.getSpecificFields();

            int localstatementAccountnumber = 1234567;
            string localstatementAccountholdername = "Bruce";
            DateTime localstatementDate = DateTime.Now;
            StatementCommonFields localStatementCommonFields = new StatementCommonFields(localstatementAccountnumber, localstatementAccountholdername, localstatementDate);

            APSUser localAPSUser = new APSUser(new APSUserId("1"), "testusername", "testpassword");
            BillingAccount localBillingAccount = new BillingAccount(new BillingAccountId("1"), new BillingCompanyId("1"), "testusername", "testpassword", localAPSUser);

            //Act
            Statement localStatement = new Statement(localStatementId, localStatementCommonFields, localStatementType, localspecificfields, localAPSUser, localBillingAccount);

            //Assert
            Assert.AreEqual(localStatement.StatementId, localStatementId);
            Assert.AreEqual(localStatement.StatementCommonFields, localStatementCommonFields);
            Assert.AreEqual(localStatement.StatementType, localStatementType);
            Assert.AreEqual(localStatement.StatementSpecificFields, localspecificfields);
            Assert.AreEqual(localStatement.APSUser, localAPSUser);
            Assert.AreEqual(localStatement.BillingAccount, localBillingAccount);
        }

 public Command(string identifier, string value, StatementType statementType, MetaData<IMeta> metaData, bool rcon)
     : base(statementType, metaData)
 {
     Identifier = identifier;
     Value = value;
     RCON = rcon;
 }

 public Statement(string text, StatementType type, ResultType result, IDictionary<string, object> parameters)
 {
     Type = type;
     Text = text;
     Result = result;
     Parameters = parameters ?? new Dictionary<string, object>();
 }

		public FbRowUpdatedEventArgs(
			DataRow				row, 
			IDbCommand			command, 
			StatementType		statementType, 
			DataTableMapping		tableMapping)
			: base(row, command, statementType, tableMapping) 
		{
		}

		protected override RowUpdatedEventArgs CreateRowUpdatedEvent(
			DataRow dataRow,
			IDbCommand command,
			StatementType statementType,
			DataTableMapping tableMapping)
		{
			return new NpgsqlRowUpdatedEventArgs(dataRow, command, statementType, tableMapping);
		}

 protected override RowUpdatingEventArgs CreateRowUpdatingEvent(
 DataRow dataRow,
 IDbCommand command,
 StatementType statementType,
 DataTableMapping tableMapping)
 {
     return null;
 }

		RowUpdatedEventArgs (DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) 
		{
			this.dataRow = dataRow;
			this.command = command;
			this.statementType = statementType;
			this.tableMapping = tableMapping;
			this.status = UpdateStatus.Continue;
		}

		protected RowUpdatedEventArgs (DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) 
		{
			this.dataRow = dataRow;
			this.command = command;
			this.statementType = statementType;
			this.tableMapping = tableMapping;
			this.errors = null;
			this.status = UpdateStatus.Continue;
			this.recordsAffected = 0; // FIXME
		}

        public void CreateStatementSpecificFields_ExpectValid()
        {
            //Arrange
            SpecificFieldsFactory localfactory = new SpecificFieldsFactory();

            string[] listspecificfields = { "You will need to pay by the 25th on the month", "1000" };

            StatementType localStatementType = new StatementType(localfactory, "Municipality", listspecificfields);

            StatementSpecificFields localspecificfields = localStatementType.getSpecificFields();

            //Assert
            Assert.IsNotNull(localspecificfields);
        }

		protected override void ApplyParameterInfo (DbParameter parameter,
				                                    DataRow datarow,
				                                    StatementType statementType,
				                                    bool whereClause)
		{
			OleDbParameter p = (OleDbParameter) parameter;
			p.Size = int.Parse (datarow ["ColumnSize"].ToString ());
			if (datarow ["NumericPrecision"] != DBNull.Value) {
				p.Precision = byte.Parse (datarow ["NumericPrecision"].ToString ());
			}
			if (datarow ["NumericScale"] != DBNull.Value) {
				p.Scale = byte.Parse (datarow ["NumericScale"].ToString ());
			}
			p.DbType = (DbType) datarow ["ProviderType"];
		}

 public RowUpdatedEventArgs(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) {
     switch(statementType) {
     case StatementType.Select:
     case StatementType.Insert:
     case StatementType.Update:
     case StatementType.Delete:
     case StatementType.Batch:
         break;
     default:
         throw ADP.InvalidStatementType(statementType);
     }
     _dataRow = dataRow;
     _command = command;
     _statementType = statementType;
     _tableMapping = tableMapping;
 }

        override protected void ApplyParameterInfo(DbParameter parameter, DataRow datarow, StatementType statementType, bool whereClause) {
            OdbcParameter p = (OdbcParameter) parameter;
            object valueType = datarow[SchemaTableColumn.ProviderType];
            p.OdbcType = (OdbcType) valueType;

            object bvalue = datarow[SchemaTableColumn.NumericPrecision];
            if (DBNull.Value != bvalue) {
                byte bval = (byte)(short)bvalue;
                p.PrecisionInternal = ((0xff != bval) ? bval : (byte)0);
            }

            bvalue = datarow[SchemaTableColumn.NumericScale];
            if (DBNull.Value != bvalue) {
                byte bval = (byte)(short)bvalue;
                p.ScaleInternal = ((0xff != bval) ? bval : (byte)0);
            }
        }

 protected override void ApplyParameterInfo(DbParameter parameter, DataRow datarow, StatementType statementType, bool whereClause)
 {
     OdbcParameter parameter2 = (OdbcParameter) parameter;
     object obj3 = datarow[SchemaTableColumn.ProviderType];
     parameter2.OdbcType = (OdbcType) obj3;
     object obj2 = datarow[SchemaTableColumn.NumericPrecision];
     if (DBNull.Value != obj2)
     {
         byte num2 = (byte) ((short) obj2);
         parameter2.PrecisionInternal = (0xff != num2) ? num2 : ((byte) 0);
     }
     obj2 = datarow[SchemaTableColumn.NumericScale];
     if (DBNull.Value != obj2)
     {
         byte num = (byte) ((short) obj2);
         parameter2.ScaleInternal = (0xff != num) ? num : ((byte) 0);
     }
 }

        private UpdateStatus _status; // UpdateStatus.Continue; /*0*/

        public RowUpdatingEventArgs(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) {
            ADP.CheckArgumentNull(dataRow, "dataRow");
            ADP.CheckArgumentNull(tableMapping, "tableMapping");
            switch(statementType) {
            case StatementType.Select:
            case StatementType.Insert:
            case StatementType.Update:
            case StatementType.Delete:
                break;
            case StatementType.Batch:
                throw ADP.NotSupportedStatementType(statementType, "RowUpdatingEventArgs");                
            default:
                throw ADP.InvalidStatementType(statementType);
            }
            _dataRow = dataRow;
            _command = command; // maybe null
            _statementType = statementType;
            _tableMapping = tableMapping; 
        }