コード例 #1
0
ファイル: parameter_collection.cs プロジェクト: BjkGkh/R106
 internal MySqlParameterCollection(MySqlCommand cmd)
 {
     indexHashCS = new Hashtable();
       indexHashCI = new Hashtable(StringComparer.CurrentCultureIgnoreCase);
       containsUnnamedParameters = false;
       Clear();
 }
コード例 #2
0
ファイル: datareader.cs プロジェクト: BjkGkh/R106
        /*
         * Because the user should not be able to directly create a
         * DataReader object, the constructors are
         * marked as internal.
         */
        internal MySqlDataReader(MySqlCommand cmd, PreparableStatement statement, CommandBehavior behavior)
        {
            this.command = cmd;
              connection = (MySqlConnection)command.Connection;
              commandBehavior = behavior;
              driver = connection.driver;
              affectedRows = -1;
              this.statement = statement;

              if (cmd.CommandType == CommandType.StoredProcedure &&
              cmd.UpdatedRowSource == UpdateRowSource.FirstReturnedRecord)
              {
            disableZeroAffectedRows = true;
              }
        }
コード例 #3
0
ファイル: MySqlHelper.cs プロジェクト: BjkGkh/R106
    /// <summary>
    /// Executes a single command against a MySQL database.  The <see cref="MySqlConnection"/> is assumed to be
    /// open when the method is called and remains open after the method completes.
    /// </summary>
    /// <param name="connection"><see cref="MySqlConnection"/> object to use</param>
    /// <param name="commandText">SQL command to be executed</param>
    /// <param name="commandParameters">Array of <see cref="MySqlParameter"/> objects to use with the command.</param>
    /// <returns></returns>
    public static int ExecuteNonQuery(MySqlConnection connection, string commandText, params MySqlParameter[] commandParameters)
    {
      //create a command and prepare it for execution
      MySqlCommand cmd = new MySqlCommand();
      cmd.Connection = connection;
      cmd.CommandText = commandText;
      cmd.CommandType = CommandType.Text;

      if (commandParameters != null)
        foreach (MySqlParameter p in commandParameters)
          cmd.Parameters.Add(p);

      int result = cmd.ExecuteNonQuery();
      cmd.Parameters.Clear();

      return result;
    }
コード例 #4
0
ファイル: CommandBuilder.cs プロジェクト: BjkGkh/R106
    /// <summary>
    /// Retrieves parameter information from the stored procedure specified 
    /// in the MySqlCommand and populates the Parameters collection of the 
    /// specified MySqlCommand object.
    /// This method is not currently supported since stored procedures are 
    /// not available in MySql.
    /// </summary>
    /// <param name="command">The MySqlCommand referencing the stored 
    /// procedure from which the parameter information is to be derived. 
    /// The derived parameters are added to the Parameters collection of the 
    /// MySqlCommand.</param>
    /// <exception cref="InvalidOperationException">The command text is not 
    /// a valid stored procedure name.</exception>
    public static void DeriveParameters(MySqlCommand command)
    {
      if (command.CommandType != CommandType.StoredProcedure)
        throw new InvalidOperationException(Resources.CanNotDeriveParametersForTextCommands);

      // retrieve the proc definition from the cache.
      string spName = command.CommandText;
      if (spName.IndexOf(".") == -1)
        spName = command.Connection.Database + "." + spName;

      try
      {
        DataSet ds = command.Connection.ProcedureCache.GetProcedure(command.Connection, spName, null);
        DataTable parameters = ds.Tables["Procedure Parameters"];
        DataTable procTable = ds.Tables["Procedures"];
        command.Parameters.Clear();
        foreach (DataRow row in parameters.Rows)
        {
          MySqlParameter p = new MySqlParameter();
          p.ParameterName = String.Format("@{0}", row["PARAMETER_NAME"]);
          if (row["ORDINAL_POSITION"].Equals(0) && p.ParameterName == "@")
            p.ParameterName = "@RETURN_VALUE";
          p.Direction = GetDirection(row);
          bool unsigned = StoredProcedure.GetFlags(row["DTD_IDENTIFIER"].ToString()).IndexOf("UNSIGNED") != -1;
          bool real_as_float = procTable.Rows[0]["SQL_MODE"].ToString().IndexOf("REAL_AS_FLOAT") != -1;
          p.MySqlDbType = MetaData.NameToType(row["DATA_TYPE"].ToString(),
            unsigned, real_as_float, command.Connection);
          if (!row["CHARACTER_MAXIMUM_LENGTH"].Equals(DBNull.Value))
            p.Size = (int)row["CHARACTER_MAXIMUM_LENGTH"];
          if (!row["NUMERIC_PRECISION"].Equals(DBNull.Value))
            p.Precision = Convert.ToByte(row["NUMERIC_PRECISION"]);
          if (!row["NUMERIC_SCALE"].Equals(DBNull.Value))
            p.Scale = Convert.ToByte(row["NUMERIC_SCALE"]);
          if (p.MySqlDbType == MySqlDbType.Set || p.MySqlDbType == MySqlDbType.Enum)
            p.PossibleValues = GetPossibleValues(row);
          command.Parameters.Add(p);
        }
      }
      catch (InvalidOperationException ioe)
      {
        throw new MySqlException(Resources.UnableToDeriveParameters, ioe);
      }
    }
コード例 #5
0
ファイル: StoredProcedure.cs プロジェクト: BjkGkh/R106
        public override void Close(MySqlDataReader reader)
        {
            base.Close(reader);
              if (String.IsNullOrEmpty(outSelect)) return;
              if ((reader.CommandBehavior & CommandBehavior.SchemaOnly) != 0) return;

              MySqlCommand cmd = new MySqlCommand(outSelect, command.Connection);
              using (MySqlDataReader rdr = cmd.ExecuteReader(reader.CommandBehavior))
              {
            ProcessOutputParameters(rdr);
              }
        }
コード例 #6
0
ファイル: StoredProcedure.cs プロジェクト: BjkGkh/R106
        private string SetUserVariables(MySqlParameterCollection parms, bool preparing)
        {
            StringBuilder setSql = new StringBuilder();

              if (serverProvidingOutputParameters) return setSql.ToString();

              string delimiter = String.Empty;
              foreach (MySqlParameter p in parms)
              {
            if (p.Direction != ParameterDirection.InputOutput) continue;

            string pName = "@" + p.BaseName;
            string uName = "@" + ParameterPrefix + p.BaseName;
            string sql = String.Format("SET {0}={1}", uName, pName);

            if (command.Connection.Settings.AllowBatch && !preparing)
            {
              setSql.AppendFormat(CultureInfo.InvariantCulture, "{0}{1}", delimiter, sql);
              delimiter = "; ";
            }
            else
            {
              MySqlCommand cmd = new MySqlCommand(sql, command.Connection);
              cmd.Parameters.Add(p);
              cmd.ExecuteNonQuery();
            }
              }
              if (setSql.Length > 0)
            setSql.Append("; ");
              return setSql.ToString();
        }
コード例 #7
0
ファイル: SchemaProvider.cs プロジェクト: BjkGkh/R106
        private void FindTables(DataTable schemaTable, string[] restrictions)
        {
            StringBuilder sql = new StringBuilder();
              StringBuilder where = new StringBuilder();
              sql.AppendFormat(CultureInfo.InvariantCulture,
               "SHOW TABLE STATUS FROM `{0}`", restrictions[1]);
              if (restrictions != null && restrictions.Length >= 3 &&
            restrictions[2] != null)
            where.AppendFormat(CultureInfo.InvariantCulture,
                   " LIKE '{0}'", restrictions[2]);
              sql.Append(where.ToString());

              string table_type = restrictions[1].ToLower() == "information_schema"
                  ?
                "SYSTEM VIEW"
                  : "BASE TABLE";

              MySqlCommand cmd = new MySqlCommand(sql.ToString(), connection);
              using (MySqlDataReader reader = cmd.ExecuteReader())
              {
            while (reader.Read())
            {
              DataRow row = schemaTable.NewRow();
              row["TABLE_CATALOG"] = null;
              row["TABLE_SCHEMA"] = restrictions[1];
              row["TABLE_NAME"] = reader.GetString(0);
              row["TABLE_TYPE"] = table_type;
              row["ENGINE"] = GetString(reader, 1);
              row["VERSION"] = reader.GetValue(2);
              row["ROW_FORMAT"] = GetString(reader, 3);
              row["TABLE_ROWS"] = reader.GetValue(4);
              row["AVG_ROW_LENGTH"] = reader.GetValue(5);
              row["DATA_LENGTH"] = reader.GetValue(6);
              row["MAX_DATA_LENGTH"] = reader.GetValue(7);
              row["INDEX_LENGTH"] = reader.GetValue(8);
              row["DATA_FREE"] = reader.GetValue(9);
              row["AUTO_INCREMENT"] = reader.GetValue(10);
              row["CREATE_TIME"] = reader.GetValue(11);
              row["UPDATE_TIME"] = reader.GetValue(12);
              row["CHECK_TIME"] = reader.GetValue(13);
              row["TABLE_COLLATION"] = GetString(reader, 14);
              row["CHECKSUM"] = reader.GetValue(15);
              row["CREATE_OPTIONS"] = GetString(reader, 16);
              row["TABLE_COMMENT"] = GetString(reader, 17);
              schemaTable.Rows.Add(row);
            }
              }
        }
コード例 #8
0
ファイル: SchemaProvider.cs プロジェクト: BjkGkh/R106
        public virtual DataTable GetProcedures(string[] restrictions)
        {
            DataTable dt = new DataTable("Procedures");
              dt.Columns.Add(new DataColumn("SPECIFIC_NAME", typeof(string)));
              dt.Columns.Add(new DataColumn("ROUTINE_CATALOG", typeof(string)));
              dt.Columns.Add(new DataColumn("ROUTINE_SCHEMA", typeof(string)));
              dt.Columns.Add(new DataColumn("ROUTINE_NAME", typeof(string)));
              dt.Columns.Add(new DataColumn("ROUTINE_TYPE", typeof(string)));
              dt.Columns.Add(new DataColumn("DTD_IDENTIFIER", typeof(string)));
              dt.Columns.Add(new DataColumn("ROUTINE_BODY", typeof(string)));
              dt.Columns.Add(new DataColumn("ROUTINE_DEFINITION", typeof(string)));
              dt.Columns.Add(new DataColumn("EXTERNAL_NAME", typeof(string)));
              dt.Columns.Add(new DataColumn("EXTERNAL_LANGUAGE", typeof(string)));
              dt.Columns.Add(new DataColumn("PARAMETER_STYLE", typeof(string)));
              dt.Columns.Add(new DataColumn("IS_DETERMINISTIC", typeof(string)));
              dt.Columns.Add(new DataColumn("SQL_DATA_ACCESS", typeof(string)));
              dt.Columns.Add(new DataColumn("SQL_PATH", typeof(string)));
              dt.Columns.Add(new DataColumn("SECURITY_TYPE", typeof(string)));
              dt.Columns.Add(new DataColumn("CREATED", typeof(DateTime)));
              dt.Columns.Add(new DataColumn("LAST_ALTERED", typeof(DateTime)));
              dt.Columns.Add(new DataColumn("SQL_MODE", typeof(string)));
              dt.Columns.Add(new DataColumn("ROUTINE_COMMENT", typeof(string)));
              dt.Columns.Add(new DataColumn("DEFINER", typeof(string)));

              StringBuilder sql = new StringBuilder("SELECT * FROM mysql.proc WHERE 1=1");
              if (restrictions != null)
              {
            if (restrictions.Length >= 2 && restrictions[1] != null)
              sql.AppendFormat(CultureInfo.InvariantCulture,
            " AND db LIKE '{0}'", restrictions[1]);
            if (restrictions.Length >= 3 && restrictions[2] != null)
              sql.AppendFormat(CultureInfo.InvariantCulture,
            " AND name LIKE '{0}'", restrictions[2]);
            if (restrictions.Length >= 4 && restrictions[3] != null)
              sql.AppendFormat(CultureInfo.InvariantCulture,
            " AND type LIKE '{0}'", restrictions[3]);
              }

              MySqlCommand cmd = new MySqlCommand(sql.ToString(), connection);
              using (MySqlDataReader reader = cmd.ExecuteReader())
              {
            while (reader.Read())
            {
              DataRow row = dt.NewRow();
              row["SPECIFIC_NAME"] = reader.GetString("specific_name");
              row["ROUTINE_CATALOG"] = DBNull.Value;
              row["ROUTINE_SCHEMA"] = reader.GetString("db");
              row["ROUTINE_NAME"] = reader.GetString("name");
              string routineType = reader.GetString("type");
              row["ROUTINE_TYPE"] = routineType;
              row["DTD_IDENTIFIER"] = routineType.ToLower(CultureInfo.InvariantCulture) == "function" ?
            (object)reader.GetString("returns") : DBNull.Value;
              row["ROUTINE_BODY"] = "SQL";
              row["ROUTINE_DEFINITION"] = reader.GetString("body");
              row["EXTERNAL_NAME"] = DBNull.Value;
              row["EXTERNAL_LANGUAGE"] = DBNull.Value;
              row["PARAMETER_STYLE"] = "SQL";
              row["IS_DETERMINISTIC"] = reader.GetString("is_deterministic");
              row["SQL_DATA_ACCESS"] = reader.GetString("sql_data_access");
              row["SQL_PATH"] = DBNull.Value;
              row["SECURITY_TYPE"] = reader.GetString("security_type");
              row["CREATED"] = reader.GetDateTime("created");
              row["LAST_ALTERED"] = reader.GetDateTime("modified");
              row["SQL_MODE"] = reader.GetString("sql_mode");
              row["ROUTINE_COMMENT"] = reader.GetString("comment");
              row["DEFINER"] = reader.GetString("definer");
              dt.Rows.Add(row);
            }
              }

              return dt;
        }
コード例 #9
0
ファイル: SchemaProvider.cs プロジェクト: BjkGkh/R106
        private void LoadTableColumns(DataTable dt, string schema,
                    string tableName, string columnRestriction)
        {
            string sql = String.Format("SHOW FULL COLUMNS FROM `{0}`.`{1}`",
                     schema, tableName);
              MySqlCommand cmd = new MySqlCommand(sql, connection);

              int pos = 1;
              using (MySqlDataReader reader = cmd.ExecuteReader())
              {
            while (reader.Read())
            {
              string colName = reader.GetString(0);
              if (columnRestriction != null && colName != columnRestriction)
            continue;
              DataRow row = dt.NewRow();
              row["TABLE_CATALOG"] = DBNull.Value;
              row["TABLE_SCHEMA"] = schema;
              row["TABLE_NAME"] = tableName;
              row["COLUMN_NAME"] = colName;
              row["ORDINAL_POSITION"] = pos++;
              row["COLUMN_DEFAULT"] = reader.GetValue(5);
              row["IS_NULLABLE"] = reader.GetString(3);
              row["DATA_TYPE"] = reader.GetString(1);
              row["CHARACTER_MAXIMUM_LENGTH"] = DBNull.Value;
              row["CHARACTER_OCTET_LENGTH"] = DBNull.Value;
              row["NUMERIC_PRECISION"] = DBNull.Value;
              row["NUMERIC_SCALE"] = DBNull.Value;
              row["CHARACTER_SET_NAME"] = reader.GetValue(2);
              row["COLLATION_NAME"] = row["CHARACTER_SET_NAME"];
              row["COLUMN_TYPE"] = reader.GetString(1);
              row["COLUMN_KEY"] = reader.GetString(4);
              row["EXTRA"] = reader.GetString(6);
              row["PRIVILEGES"] = reader.GetString(7);
              row["COLUMN_COMMENT"] = reader.GetString(8);
              ParseColumnRow(row);
              dt.Rows.Add(row);
            }
              }
        }
コード例 #10
0
ファイル: Statement.cs プロジェクト: BjkGkh/R106
 private Statement(MySqlCommand cmd)
 {
     command = cmd;
       buffers = new ArrayList();
 }
コード例 #11
0
ファイル: MySqlScript.cs プロジェクト: BjkGkh/R106
    /// <summary>
    /// Executes this instance.
    /// </summary>
    /// <returns>The number of statements executed as part of the script.</returns>
	public int Execute()
	{
		bool openedConnection = false;

		if (connection == null)
			throw new InvalidOperationException(Resources.ConnectionNotSet);
		if (query == null || query.Length == 0)
			return 0;

		// next we open up the connetion if it is not already open
		if (connection.State != ConnectionState.Open)
		{
			openedConnection = true;
			connection.Open();
		}

		// since we don't allow setting of parameters on a script we can 
		// therefore safely allow the use of user variables.  no one should be using
		// this connection while we are using it so we can temporarily tell it
		// to allow the use of user variables
		bool allowUserVars = connection.Settings.AllowUserVariables;
		connection.Settings.AllowUserVariables = true;

		try
		{
			bool ansiQuotes = -1 != -1;
			bool noBackslashEscapes = -1 != -1;

			// first we break the query up into smaller queries
			List<ScriptStatement> statements = BreakIntoStatements(ansiQuotes, noBackslashEscapes);

			int count = 0;
			MySqlCommand cmd = new MySqlCommand(null, connection);
			foreach (ScriptStatement statement in statements)
			{
				if (String.IsNullOrEmpty(statement.text)) continue;
				cmd.CommandText = statement.text;
				try
				{
					cmd.ExecuteNonQuery();
					count++;
					OnQueryExecuted(statement);
				}
				catch (Exception ex)
				{
					if (Error == null)
						throw;
					if (!OnScriptError(ex))
						break;
				}
			}
			OnScriptCompleted();
			return count;
		}
		finally
		{
			connection.Settings.AllowUserVariables = allowUserVars;
			if (openedConnection)
			{
				connection.Close();
			}
		}
	}
コード例 #12
0
ファイル: dataadapter.cs プロジェクト: BjkGkh/R106
 public MySqlDataAdapter(string selectCommandText, MySqlConnection connection)
     : this()
 {
     SelectCommand = new MySqlCommand(selectCommandText, connection);
 }
コード例 #13
0
ファイル: dataadapter.cs プロジェクト: BjkGkh/R106
 public MySqlDataAdapter(MySqlCommand selectCommand)
     : this()
 {
     SelectCommand = selectCommand;
 }
コード例 #14
0
ファイル: Connection.cs プロジェクト: BjkGkh/R106
		public void CancelQuery(int timeout)
		{
			using (MySqlConnection c = Clone())
			{
				c.isKillQueryConnection = true;
				c.Open();
				string commandText = "KILL QUERY " + ServerThread;
				MySqlCommand cmd = new MySqlCommand(commandText, c);
				cmd.CommandTimeout = timeout;
				cmd.ExecuteNonQuery();
			}
		}
コード例 #15
0
ファイル: Connection.cs プロジェクト: BjkGkh/R106
		internal string CurrentDatabase()
		{
			if (Database != null && Database.Length > 0)
				return Database;
			MySqlCommand cmd = new MySqlCommand("SELECT database()", this);
			return cmd.ExecuteScalar().ToString();
		}
コード例 #16
0
ファイル: Connection.cs プロジェクト: BjkGkh/R106
		public new MySqlCommand CreateCommand()
		{
			// Return a new instance of a command object.
			MySqlCommand c = new MySqlCommand();
			c.Connection = this;
			return c;
		}
コード例 #17
0
ファイル: Statement.cs プロジェクト: BjkGkh/R106
 public Statement(MySqlCommand cmd, string text)
     : this(cmd)
 {
     commandText = text;
 }
コード例 #18
0
ファイル: command.cs プロジェクト: BjkGkh/R106
        /// <summary>
        /// Creates a clone of this MySqlCommand object.  CommandText, Connection, and Transaction properties
        /// are included as well as the entire parameter list.
        /// </summary>
        /// <returns>The cloned MySqlCommand object</returns>
        public MySqlCommand Clone()
        {
            MySqlCommand clone = new MySqlCommand(cmdText, connection, curTransaction);
              clone.CommandType = CommandType;
              clone.commandTimeout = commandTimeout;
              clone.useDefaultTimeout = useDefaultTimeout;
              clone.batchableCommandText = batchableCommandText;
              clone.UpdatedRowSource = UpdatedRowSource;
              clone.EnableCaching = EnableCaching;
              clone.CacheAge = CacheAge;

              foreach (MySqlParameter p in parameters)
              {
            clone.Parameters.Add(p.Clone());
              }
              return clone;
        }
コード例 #19
0
ファイル: SchemaProvider.cs プロジェクト: BjkGkh/R106
 private string GetSqlMode()
 {
     MySqlCommand cmd = new MySqlCommand("SELECT @@SQL_MODE", connection);
       return cmd.ExecuteScalar().ToString();
 }
コード例 #20
0
ファイル: command.cs プロジェクト: BjkGkh/R106
 internal void AddToBatch(MySqlCommand command)
 {
     if (batch == null)
     batch = new List<MySqlCommand>();
       batch.Add(command);
 }
コード例 #21
0
ファイル: SchemaProvider.cs プロジェクト: BjkGkh/R106
        public virtual DataTable GetIndexColumns(string[] restrictions)
        {
            DataTable dt = new DataTable("IndexColumns");
              dt.Columns.Add("INDEX_CATALOG", typeof(string));
              dt.Columns.Add("INDEX_SCHEMA", typeof(string));
              dt.Columns.Add("INDEX_NAME", typeof(string));
              dt.Columns.Add("TABLE_NAME", typeof(string));
              dt.Columns.Add("COLUMN_NAME", typeof(string));
              dt.Columns.Add("ORDINAL_POSITION", typeof(int));
              dt.Columns.Add("SORT_ORDER", typeof(string));

              int max = restrictions == null ? 4 : restrictions.Length;
              string[] tableRestrictions = new string[Math.Max(max, 4)];
              if (restrictions != null)
            restrictions.CopyTo(tableRestrictions, 0);
              tableRestrictions[3] = "BASE TABLE";
              DataTable tables = GetTables(tableRestrictions);

              foreach (DataRow table in tables.Rows)
              {
            string sql = String.Format("SHOW INDEX FROM `{0}`.`{1}`",
                       table["TABLE_SCHEMA"], table["TABLE_NAME"]);
            MySqlCommand cmd = new MySqlCommand(sql, connection);
            using (MySqlDataReader reader = cmd.ExecuteReader())
            {
              while (reader.Read())
              {
            string key_name = GetString(reader, reader.GetOrdinal("KEY_NAME"));
            string col_name = GetString(reader, reader.GetOrdinal("COLUMN_NAME"));

            if (restrictions != null)
            {
              if (restrictions.Length >= 4 && restrictions[3] != null &&
                key_name != restrictions[3]) continue;
              if (restrictions.Length >= 5 && restrictions[4] != null &&
                col_name != restrictions[4]) continue;
            }
            DataRow row = dt.NewRow();
            row["INDEX_CATALOG"] = null;
            row["INDEX_SCHEMA"] = table["TABLE_SCHEMA"];
            row["INDEX_NAME"] = key_name;
            row["TABLE_NAME"] = GetString(reader, reader.GetOrdinal("TABLE"));
            row["COLUMN_NAME"] = col_name;
            row["ORDINAL_POSITION"] = reader.GetValue(reader.GetOrdinal("SEQ_IN_INDEX"));
            row["SORT_ORDER"] = reader.GetString("COLLATION");
            dt.Rows.Add(row);
              }
            }
              }

              return dt;
        }
コード例 #22
0
ファイル: command.cs プロジェクト: BjkGkh/R106
        internal string GetCommandTextForBatching()
        {
            if (batchableCommandText == null)
              {
            // if the command starts with insert and is "simple" enough, then
            // we can use the multi-value form of insert
            if (String.Compare(CommandText.Substring(0, 6), "INSERT", true) == 0)
            {
              MySqlCommand cmd = new MySqlCommand("SELECT @@sql_mode", Connection);
              string sql_mode = cmd.ExecuteScalar().ToString().ToUpper(CultureInfo.InvariantCulture);
              MySqlTokenizer tokenizer = new MySqlTokenizer(CommandText);
              tokenizer.AnsiQuotes = sql_mode.IndexOf("ANSI_QUOTES") != -1;
              tokenizer.BackslashEscapes = sql_mode.IndexOf("NO_BACKSLASH_ESCAPES") == -1;
              string token = tokenizer.NextToken().ToLower(CultureInfo.InvariantCulture);
              while (token != null)
              {
            if (token.ToUpper(CultureInfo.InvariantCulture) == "VALUES" &&
                !tokenizer.Quoted)
            {
              token = tokenizer.NextToken();
              Debug.Assert(token == "(");

              // find matching right paren, and ensure that parens
              // are balanced.
              int openParenCount = 1;
              while (token != null)
              {
                batchableCommandText += token;
                token = tokenizer.NextToken();

                if (token == "(")
                  openParenCount++;
                else if (token == ")")
                  openParenCount--;

                if (openParenCount == 0)
                  break;
              }

              if (token != null)
                batchableCommandText += token;
              token = tokenizer.NextToken();
              if (token != null && (token == "," ||
                  token.ToUpper(CultureInfo.InvariantCulture) == "ON"))
              {
                batchableCommandText = null;
                break;
              }
            }
            token = tokenizer.NextToken();
              }
            }
            // Otherwise use the command verbatim
            else batchableCommandText = CommandText;
              }

              return batchableCommandText;
        }
コード例 #23
0
ファイル: SchemaProvider.cs プロジェクト: BjkGkh/R106
        public virtual DataTable GetUDF(string[] restrictions)
        {
            string sql = "SELECT name,ret,dl FROM mysql.func";
              if (restrictions != null)
              {
            if (restrictions.Length >= 1 && !String.IsNullOrEmpty(restrictions[0]))
              sql += String.Format(" WHERE name LIKE '{0}'", restrictions[0]);
              }

              DataTable dt = new DataTable("User-defined Functions");
              dt.Columns.Add("NAME", typeof(string));
              dt.Columns.Add("RETURN_TYPE", typeof(int));
              dt.Columns.Add("LIBRARY_NAME", typeof(string));

              MySqlCommand cmd = new MySqlCommand(sql, connection);
              try
              {
            using (MySqlDataReader reader = cmd.ExecuteReader())
            {
              while (reader.Read())
              {
            DataRow row = dt.NewRow();
            row[0] = reader.GetString(0);
            row[1] = reader.GetInt32(1);
            row[2] = reader.GetString(2);
            dt.Rows.Add(row);
              }
            }
              }
              catch (MySqlException ex)
              {
            if (ex.Number != (int)MySqlErrorCode.TableAccessDenied)
              throw;
            throw new MySqlException(Resources.UnableToEnumerateUDF, ex);
              }

              return dt;
        }
コード例 #24
0
ファイル: command.cs プロジェクト: BjkGkh/R106
 /// <summary>
 /// Reset SQL_SELECT_LIMIT that could have been modified by CommandBehavior.
 /// </summary>
 internal void ResetSqlSelectLimit()
 {
     // if we are supposed to reset the sql select limit, do that here
       if (resetSqlSelect)
       {
     resetSqlSelect = false;
     MySqlCommand command = new MySqlCommand("SET SQL_SELECT_LIMIT=DEFAULT", connection);
     command.internallyCreated = true;
     command.ExecuteNonQuery();
       }
 }
コード例 #25
0
ファイル: SchemaProvider.cs プロジェクト: BjkGkh/R106
        /// <summary>
        /// GetForeignKeysOnTable retrieves the foreign keys on the given table.
        /// Since MySQL supports foreign keys on versions prior to 5.0, we can't  use
        /// information schema.  MySQL also does not include any type of SHOW command
        /// for foreign keys so we have to resort to use SHOW CREATE TABLE and parsing
        /// the output.
        /// </summary>
        /// <param name="fkTable">The table to store the key info in.</param>
        /// <param name="tableToParse">The table to get the foeign key info for.</param>
        /// <param name="filterName">Only get foreign keys that match this name.</param>
        /// <param name="includeColumns">Should column information be included in the table.</param>
        private void GetForeignKeysOnTable(DataTable fkTable, DataRow tableToParse,
                       string filterName, bool includeColumns)
        {
            string sqlMode = GetSqlMode();

              if (filterName != null)
            filterName = filterName.ToLower(CultureInfo.InvariantCulture);

              string sql = string.Format("SHOW CREATE TABLE `{0}`.`{1}`",
                     tableToParse["TABLE_SCHEMA"], tableToParse["TABLE_NAME"]);
              string lowerBody = null, body = null;
              MySqlCommand cmd = new MySqlCommand(sql, connection);
              using (MySqlDataReader reader = cmd.ExecuteReader())
              {
            reader.Read();
            body = reader.GetString(1);
            lowerBody = body.ToLower(CultureInfo.InvariantCulture);
              }

              MySqlTokenizer tokenizer = new MySqlTokenizer(lowerBody);
              tokenizer.AnsiQuotes = sqlMode.IndexOf("ANSI_QUOTES") != -1;
              tokenizer.BackslashEscapes = sqlMode.IndexOf("NO_BACKSLASH_ESCAPES") != -1;

              while (true)
              {
            string token = tokenizer.NextToken();
            // look for a starting contraint
            while (token != null && (token != "constraint" || tokenizer.Quoted))
              token = tokenizer.NextToken();
            if (token == null) break;

            ParseConstraint(fkTable, tableToParse, tokenizer, includeColumns);
              }
        }
コード例 #26
0
ファイル: MySqlHelper.cs プロジェクト: BjkGkh/R106
    /// <summary>
    /// Executes a single SQL command and returns the resultset in a <see cref="DataSet"/>.  
    /// The state of the <see cref="MySqlConnection"/> object remains unchanged after execution
    /// of this method.
    /// </summary>
    /// <param name="connection"><see cref="MySqlConnection"/> object to use</param>
    /// <param name="commandText">Command to execute</param>
    /// <param name="commandParameters">Parameters to use for the command</param>
    /// <returns><see cref="DataSet"/> containing the resultset</returns>
    public static DataSet ExecuteDataset(MySqlConnection connection, string commandText, params MySqlParameter[] commandParameters)
    {
      //create a command and prepare it for execution
      MySqlCommand cmd = new MySqlCommand();
      cmd.Connection = connection;
      cmd.CommandText = commandText;
      cmd.CommandType = CommandType.Text;

      if (commandParameters != null)
        foreach (MySqlParameter p in commandParameters)
          cmd.Parameters.Add(p);

      //create the DataAdapter & DataSet
      MySqlDataAdapter da = new MySqlDataAdapter(cmd);
      DataSet ds = new DataSet();

      //fill the DataSet using default values for DataTable names, etc.
      da.Fill(ds);

      // detach the MySqlParameters from the command object, so they can be used again.			
      cmd.Parameters.Clear();

      //return the dataset
      return ds;
    }
コード例 #27
0
ファイル: StoredProcedure.cs プロジェクト: BjkGkh/R106
 public StoredProcedure(MySqlCommand cmd, string text)
     : base(cmd, text)
 {
 }
コード例 #28
0
ファイル: MySqlHelper.cs プロジェクト: BjkGkh/R106
    /// <summary>
    /// Executes a single command against a MySQL database, possibly inside an existing transaction.
    /// </summary>
    /// <param name="connection"><see cref="MySqlConnection"/> object to use for the command</param>
    /// <param name="transaction"><see cref="MySqlTransaction"/> object to use for the command</param>
    /// <param name="commandText">Command text to use</param>
    /// <param name="commandParameters">Array of <see cref="MySqlParameter"/> objects to use with the command</param>
    /// <param name="ExternalConn">True if the connection should be preserved, false if not</param>
    /// <returns><see cref="MySqlDataReader"/> object ready to read the results of the command</returns>
    private static MySqlDataReader ExecuteReader(MySqlConnection connection, MySqlTransaction transaction, string commandText, MySqlParameter[] commandParameters, bool ExternalConn)
    {
      //create a command and prepare it for execution
      MySqlCommand cmd = new MySqlCommand();
      cmd.Connection = connection;
      cmd.Transaction = transaction;
      cmd.CommandText = commandText;
      cmd.CommandType = CommandType.Text;

      if (commandParameters != null)
        foreach (MySqlParameter p in commandParameters)
          cmd.Parameters.Add(p);

      //create a reader
      MySqlDataReader dr;

      // call ExecuteReader with the appropriate CommandBehavior
      if (ExternalConn)
      {
        dr = cmd.ExecuteReader();
      }
      else
      {
        dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
      }

      // detach the SqlParameters from the command object, so they can be used again.
      cmd.Parameters.Clear();

      return dr;
    }
コード例 #29
0
ファイル: CharSetMap.cs プロジェクト: BjkGkh/R106
    internal static void InitCollections(MySqlConnection connection)
    {
      defaultCollations = new Dictionary<string, string>();
      maxLengths = new Dictionary<string, int>();

      MySqlCommand cmd = new MySqlCommand("SHOW CHARSET", connection);
      using (MySqlDataReader reader = cmd.ExecuteReader())
      {
        while (reader.Read())
        {
          defaultCollations.Add(reader.GetString(0), reader.GetString(2));
          maxLengths.Add(reader.GetString(0), Convert.ToInt32(reader.GetValue(3)));
        }
      }
    }
コード例 #30
0
ファイル: MySqlHelper.cs プロジェクト: BjkGkh/R106
    /// <summary>
    /// Execute a single command against a MySQL database.
    /// </summary>
    /// <param name="connection"><see cref="MySqlConnection"/> object to use</param>
    /// <param name="commandText">Command text to use for the command</param>
    /// <param name="commandParameters">Parameters to use for the command</param>
    /// <returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
    public static object ExecuteScalar(MySqlConnection connection, string commandText, params MySqlParameter[] commandParameters)
    {
      //create a command and prepare it for execution
      MySqlCommand cmd = new MySqlCommand();
      cmd.Connection = connection;
      cmd.CommandText = commandText;
      cmd.CommandType = CommandType.Text;

      if (commandParameters != null)
        foreach (MySqlParameter p in commandParameters)
          cmd.Parameters.Add(p);

      //execute the command & return the results
      object retval = cmd.ExecuteScalar();

      // detach the SqlParameters from the command object, so they can be used again.
      cmd.Parameters.Clear();
      return retval;

    }