Driver={MariaDB ODBC Driver};Server=localhost;Port=3306;Database=your_database_name;Uid=your_username;Pwd=your_password;

async function executeDatabaseOperations() {
    let conn;
    try {
        conn = await pool.getConnection(); // Get a connection from the pool

        // --- SELECT Query ---
        const rows = await conn.query("SELECT id, name FROM your_table_name WHERE status = ?", ["active"]);
        console.log("Selected Rows:", rows);

        // --- INSERT Query (with parameters for security) ---
        const res = await conn.query("INSERT INTO your_table_name (name, status) VALUES (?, ?)", ["New Entry", "pending"]);
        console.log("Insert Result:", res); // res will contain { affectedRows: 1, insertId: ..., warningStatus: 0 }

    } catch (err) {
        console.error("Database operation error:", err);
        throw err; // Re-throw to handle higher up
    } finally {
        if (conn) {
            conn.release(); // Release connection back to the pool
            console.log("Connection released to pool.");
        }
    }
}

// Call the async function
executeDatabaseOperations()
    .then(() => console.log("All database operations attempted."))
    .catch((err) => console.error("Overall operation failed:", err))
    .finally(() => {
        // Optional: End the pool when your application is shutting down
        // pool.end();
        // console.log("Connection pool ended.");
    });

const mariadb = require('mariadb/callback');

// Create a single connection
mariadb.createConnection({
    host: 'localhost',
    port: 3306,
    user: 'your_username',
    password: 'your_password',
    database: 'your_database_name'
}, (err, conn) => {
    if (err) {
        console.error("Connection error:", err);
        return;
    }

    console.log("Connected using Callback API.");

    // Execute a query
    conn.query("SELECT 1 AS val", (queryErr, rows) => {
        if (queryErr) {
            console.error("Query error:", queryErr);
            conn.end(); // Close connection on error
            return;
        }
        console.log("Query Result (Callback):", rows);

        // Close the connection when done
        conn.end((endErr) => {
            if (endErr) {
                console.error("Error closing connection:", endErr);
            } else {
                console.log("Connection closed (Callback).");
            }
        });
    });
});

sudo apt update
sudo apt install libmariadb-dev # Or libmysqlclient-dev

# If using Bundler (e.g., in a Rails project's Gemfile)
# Gemfile
# gem 'mysql2'
bundle install

# Or directly
gem install mysql2

require 'mysql2'

begin
  client = Mysql2::Client.new(
    host: 'localhost',
    port: 3306,
    username: 'your_username',
    password: 'your_password',
    database: 'your_database_name'
  )
  puts "Successfully connected to MariaDB!"

  # ... database operations ...

rescue Mysql2::Error => e
  puts "Error connecting to database: #{e.message}"
ensure
  client&.close # Ensure the connection is closed
end

# Assuming 'client' is an open connection
results = client.query("SELECT id, name FROM your_table_name WHERE status = 'active'")

puts "\nSelected Rows:"
results.each do |row|
  puts "ID: #{row['id']}, Name: #{row['name']}"
end

# INSERT Example (using prepared statement)
statement = client.prepare("INSERT INTO your_table_name (name, status) VALUES (?, ?)")
insert_result = statement.execute("New Item", "pending")
puts "\nRows inserted: #{insert_result.affected_rows}, Last ID: #{insert_result.last_id}"

# UPDATE Example
update_result = client.query("UPDATE your_table_name SET status = 'completed' WHERE name = 'New Item'")
puts "Rows updated: #{update_result.affected_rows}"

# DELETE Example
delete_result = client.query("DELETE FROM your_table_name WHERE name = 'New Item'")
puts "Rows deleted: #{delete_result.affected_rows}"

# Assuming 'client' is an open connection
statement = client.prepare("SELECT * FROM users WHERE login_count = ?")

# Execute with different parameters
result1 = statement.execute(1)
puts "\nUsers with login_count = 1:"
result1.each { |row| puts row.inspect }

result2 = statement.execute(5)
puts "\nUsers with login_count = 5:"
result2.each { |row| puts row.inspect }

Install-Package MySqlConnector -Version 2.4.0 # Use the latest stable version

<PackageReference Include="MySqlConnector" Version="2.4.0" /> ```

**c. Using .NET CLI:**

```bash
dotnet add package MySqlConnector --version 2.4.0 # Use the latest stable version

string connectionString = "Server=localhost;Port=3306;Database=your_database_name;Uid=your_username;Pwd=your_password;";

using MySqlConnector;
using System;
using System.Data;
using System.Threading.Tasks;

public class MariaDBConnectorNetQuickstart
{
    private static string connectionString = "Server=localhost;Port=3306;Database=your_database_name;Uid=your_username;Pwd=your_password;";

    public static async Task Main(string[] args)
    {
        Console.WriteLine("Connecting to MariaDB...");

        try
        {
            await using var connection = new MySqlConnection(connectionString);
            await connection.OpenAsync();
            Console.WriteLine("Connection successful!");

            // Call your data operations here
            await SelectData(connection);
            await InsertData(connection);

            Console.WriteLine("Operations completed.");
        }
        catch (MySqlException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    // ... (Data operation methods will go here)
}

    private static async Task SelectData(MySqlConnection connection)
    {
        string query = "SELECT id, name FROM your_table_name;";
        await using var command = new MySqlCommand(query, connection);

        Console.WriteLine("\nRetrieving data:");
        await using var reader = await command.ExecuteReaderAsync();
        while (await reader.ReadAsync())
        {
            int id = reader.GetInt32("id");
            string name = reader.GetString("name");
            Console.WriteLine($"ID: {id}, Name: {name}");
        }
    }

    private static async Task InsertData(MySqlConnection connection)
    {
        string query = "INSERT INTO your_table_name (name, status) VALUES (@name, @status);";
        await using var command = new MySqlCommand(query, connection);

        command.Parameters.AddWithValue("@name", "New Item");
        command.Parameters.AddWithValue("@status", "active");

        int rowsAffected = await command.ExecuteNonQueryAsync();
        Console.WriteLine($"\nRows inserted: {rowsAffected}");
    }

<dependency>
    <groupId>org.mariadb</groupId>
    <artifactId>r2dbc-mariadb-0.9.1-spec</artifactId>
    <version>1.4.1</version> </dependency>

// Gradle
implementation 'org.mariadb:r2dbc-mariadb-0.9.1-spec:1.4.1' // Use the latest stable version

import io.r2dbc.spi.ConnectionFactories;
import io.r2dbc.spi.ConnectionFactory;
import io.r2dbc.spi.ConnectionFactoryOptions;
import io.r2dbc.spi.Connection;
import io.r2dbc.spi.Result;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import static io.r2dbc.spi.ConnectionFactoryOptions.DATABASE;
import static io.r2dbc.spi.ConnectionFactoryOptions.DRIVER;
import static io.r2dbc.spi.ConnectionFactoryOptions.HOST;
import static io.r2dbc.spi.ConnectionFactoryOptions.PASSWORD;
import static io.r2dbc.spi.ConnectionFactoryOptions.PORT;
import static io.r2dbc.spi.ConnectionFactoryOptions.USER;
import org.mariadb.r2dbc.MariadbConnectionConfiguration;
import org.mariadb.r2dbc.MariadbConnectionFactory;

public class MariaDBR2DBCQuickstart {

    public static void main(String[] args) {
        // Option 1: Using ConnectionFactoryOptions Builder (Recommended for explicit configuration)
        MariadbConnectionConfiguration conf = MariadbConnectionConfiguration.builder()
                .host("localhost")
                .port(3306)
                .username("your_username")
                .password("your_password")
                .database("your_database_name")
                .build();
        ConnectionFactory factory = new MariadbConnectionFactory(conf);

        // Option 2: Using a R2DBC Connection URL
        // ConnectionFactory factory = ConnectionFactories.get("r2dbc:mariadb://your_username:your_password@localhost:3306/your_database_name");

        Mono<Connection> connectionMono = Mono.from(factory.create());

        // --- Example: Select Data ---
        connectionMono
            .flatMapMany(connection ->
                Flux.from(connection.createStatement("SELECT id, name FROM your_table_name WHERE status = ?")
                                   .bind(0, "active") // Bind parameter by index
                                   .execute())
                    .flatMap(result -> result.map((row, rowMetadata) -> {
                        int id = row.get("id", Integer.class);
                        String name = row.get("name", String.class);
                        return "ID: " + id + ", Name: " + name;
                    }))
                    .doFinally(signalType -> Mono.from(connection.close()).subscribe()) // Close connection when done
            )
            .doOnNext(System.out::println) // Print each row
            .doOnError(Throwable::printStackTrace) // Handle errors
            .blockLast(); // Block to ensure the main thread waits for completion (for quickstart example)


        // --- Example: Insert Data ---
        connectionMono
            .flatMap(connection ->
                Mono.from(connection.createStatement("INSERT INTO your_table_name (name, status) VALUES (?, ?)")
                                   .bind(0, "New Item")
                                   .bind(1, "pending")
                                   .execute())
                    .flatMap(Result::getRowsUpdated) // Get number of affected rows
                    .doFinally(signalType -> Mono.from(connection.close()).subscribe()) // Close connection
            )
            .doOnNext(rowsUpdated -> System.out.println("Rows inserted: " + rowsUpdated))
            .doOnError(Throwable::printStackTrace)
            .block(); // Block for simplicity in quickstart


        System.out.println("MariaDB R2DBC operations completed.");
    }
}

<dependency>
    <groupId>org.mariadb.jdbc</groupId>
    <artifactId>mariadb-java-client</artifactId>
    <version>3.3.3</version> </dependency>

dependencies {
    implementation 'org.mariadb.jdbc:mariadb-java-client:3.3.3' // Use the latest stable version
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class MariaDBQuickstart {

    // Database connection parameters
    static final String DB_URL = "jdbc:mariadb://localhost:3306/your_database_name";
    static final String USER = "your_username";
    static final String PASS = "your_password";

    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            // Register JDBC driver (optional for modern JDBC, but good practice)
            // Class.forName("org.mariadb.jdbc.Driver");

            System.out.println("Connecting to database...");
            conn = DriverManager.getConnection(DB_URL, USER, PASS);

            System.out.println("Creating statement...");
            stmt = conn.createStatement();
            String sql = "SELECT id, name FROM your_table_name";
            rs = stmt.executeQuery(sql);

            // Extract data from result set
            while (rs.next()) {
                // Retrieve by column name
                int id = rs.getInt("id");
                String name = rs.getString("name");

                // Display values
                System.out.print("ID: " + id);
                System.out.println(", Name: " + name);
            }
        } catch (SQLException se) {
            // Handle errors for JDBC
            se.printStackTrace();
        } finally {
            // Close resources in finally block
            try {
                if (rs != null) rs.close();
            } catch (SQLException se2) {
                // Do nothing
            }
            try {
                if (stmt != null) stmt.close();
            } catch (SQLException se2) {
                // Do nothing
            }
            try {
                if (conn != null) conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
            System.out.println("Database resources closed.");
        }
    }
}

sudo yum install MariaDB-shared

sudo yum install MariaDB-devel

sudo apt-get install libmariadb3

sudo apt-get install libmariadb-dev

sudo zypper install MariaDB-shared

sudo zypper install MariaDB-devel

{ok, Pid} = mysql:start_link([{host, "localhost"}, {user, "myuser"}, {password, "mypass"}, {database, "mydb"}]).

% Select data
{ok, ColumnNames, Rows} = mysql:query(Pid, <<"SELECT id, name FROM mytable WHERE status = ?">>, [<<"active">>]).

% Insert data
ok = mysql:query(Pid, "INSERT INTO mytable (col1, col2) VALUES (?, ?)", [<<"value1">>, 123]).

mysql:stop(Pid).

pip install mariadb

pip install mariadb==1.1.14

# Pure Python (recommended for most users)
pip install --pre mariadb

# Pre-compiled binary wheels (best for production)
pip install --pre mariadb[binary,pool]

# C extension from source (maximum performance, requires MariaDB Connector/C)
pip install --pre mariadb[c,pool]

import mariadb
import sys

# 1. Database Connection Configuration
db_config = {
    'host': 'localhost',
    'port': 3306,
    'user': 'your_username',
    'password': 'your_password',
    'database': 'your_database_name'
}

def run_db_operations():
    conn = None
    cursor = None
    try:
        # 2. Establish a Connection
        print("Connecting to MariaDB...")
        conn = mariadb.connect(**db_config)
        print("Connection successful!")

        # 3. Create a Cursor Object
        cursor = conn.cursor()

        # ... (rest of the code continues below)

import mariadb
import sys

# 1. Database Connection URI (Available since MariaDB Connector/Python 2.0)
DATABASE_URL = "mariadb://your_username:your_password@localhost:3306/your_database_name"

def run_db_operations():
    conn = None
    cursor = None
    try:
        # 2. Establish a Connection
        print("Connecting to MariaDB...")
        conn = mariadb.connect(DATABASE_URL)
        print("Connection successful!")

        # 3. Create a Cursor Object
        cursor = conn.cursor()

        # --- Example: Create a Table (if it doesn't exist) ---
        try:
            cursor.execute("""
                CREATE TABLE IF NOT EXISTS users (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    name VARCHAR(255) NOT NULL,
                    email VARCHAR(255) UNIQUE
                )
            """)
            conn.commit() # Commit the transaction for DDL
            print("Table 'users' created or already exists.")
        except mariadb.Error as e:
            print(f"Error creating table: {e}")
            conn.rollback() # Rollback in case of DDL error

        # --- Example: Insert Data (Parameterized Query) ---
        print("\nInserting data...")
        insert_query = "INSERT INTO users (name, email) VALUES (?, ?)"
        try:
            cursor.execute(insert_query, ("Alice Wonderland", "alice@example.com"))
            cursor.execute(insert_query, ("Bob Builder", "bob@example.com"))
            conn.commit() # Commit the transaction for DML
            print(f"Inserted {cursor.rowcount} rows.")
            print(f"Last inserted ID: {cursor.lastrowid}")
        except mariadb.IntegrityError as e:
            print(f"Error inserting data (might be duplicate email): {e}")
            conn.rollback()
        except mariadb.Error as e:
            print(f"Error inserting data: {e}")
            conn.rollback()

        # --- Example: Select Data ---
        print("\nSelecting data...")
        select_query = "SELECT id, name, email FROM users WHERE name LIKE ?"
        cursor.execute(select_query, ("%Alice%",)) # Note the comma for single parameter tuple
        
        print("Fetched data:")
        for row in cursor:
            print(f"ID: {row[0]}, Name: {row[1]}, Email: {row[2]}")

        # --- Example: Update Data ---
        print("\nUpdating data...")
        update_query = "UPDATE users SET name = ? WHERE email = ?"
        cursor.execute(update_query, ("Alicia Wonderland", "alice@example.com"))
        conn.commit()
        print(f"Rows updated: {cursor.rowcount}")

        # --- Example: Delete Data ---
        print("\nDeleting data...")
        delete_query = "DELETE FROM users WHERE name = ?"
        cursor.execute(delete_query, ("Bob Builder",))
        conn.commit()
        print(f"Rows deleted: {cursor.rowcount}")

    except mariadb.Error as e:
        print(f"An error occurred: {e}")
        sys.exit(1)
    finally:
        # 4. Close Cursor and Connection
        if cursor:
            cursor.close()
            print("Cursor closed.")
        if conn:
            conn.close()
            print("Connection closed.")

if __name__ == "__main__":
    run_db_operations()

import asyncio
import mariadb

async def async_operations():
    # Connect asynchronously
    conn = await mariadb.asyncConnect(
        "mariadb://your_username:your_password@localhost/your_database_name"
    )
    
    try:
        cursor = await conn.cursor()
        
        # Execute async query
        await cursor.execute("SELECT id, name, email FROM users WHERE id = ?", (1,))
        user = await cursor.fetchone()
        print(f"User: {user}")
        
        await cursor.close()
    finally:
        await conn.close()

# Run async function
asyncio.run(async_operations())

import asyncio
import mariadb

async def main():
    # Create async pool
    pool = await mariadb.create_async_pool(
        "mariadb://user:password@localhost/mydb",
        min_size=5,
        max_size=20
    )
    
    # Use pool
    async with await pool.acquire() as conn:
        async with conn.cursor() as cursor:
            await cursor.execute("SELECT COUNT(*) FROM users")
            count = (await cursor.fetchone())[0]
            print(f"Total users: {count}")
    
    await pool.close()

asyncio.run(main())