JDBC

Se inhabilitaron las versiones 1.0 y 1.1 del protocolo de seguridad TLS. Para establecer conexiones, usa TLS 1.2 o una versión posterior.

Google Apps Script puede conectarse a bases de datos externas a través del servicio de JDBC, un wrapper de la tecnología estándar de conectividad a bases de datos de Java. El servicio de JDBC admite Google Cloud SQL para bases de datos de MySQL, Microsoft SQL Server, Oracle y PostgreSQL.

Si tu hoja de cálculo está creciendo demasiado o tienes problemas de tiempo de espera con cálculos complejos, trasladar tus datos a una base de datos externa puede mejorar significativamente el rendimiento y la confiabilidad.

Para actualizar una base de datos externa con JDBC, tu secuencia de comandos debe abrir una conexión a la base de datos y, luego, enviar instrucciones SQL para realizar los cambios.

Bases de datos de Google Cloud SQL

Google Cloud SQL te permite crear bases de datos relacionales que residen en la nube de Google. Es posible que Cloud SQL genere cargos según tu uso.

Crea una instancia de Google Cloud SQL siguiendo los pasos que se indican en la guía de inicio rápido de Cloud SQL.

Crea conexiones de Google Cloud SQL

Existen dos formas de establecer una conexión con una base de datos de Google Cloud SQL a través del servicio JDBC de Apps Script:

Ambos son válidos, pero el segundo método requiere que autorices un conjunto de rangos de IP para acceder a tu base de datos.

Este método crea una conexión a una instancia de MySQL de Google Cloud SQL con el método Jdbc.getCloudSqlConnection. La URL de la base de datos tiene la forma jdbc:google:mysql://subname, donde subname es el nombre de conexión de la instancia de MySQL que aparece en la página Descripción general de la instancia de Cloud SQL en la consola de Google Cloud.

Para conectarte a Cloud SQL SQL Server, consulta Jdbc.getConnection.

Usa Jdbc.getConnection

Para usar este método, debes autorizar ciertos rangos de direcciones IP de enrutamiento entre dominios sin clases (CIDR) para que los servidores de Apps Script puedan conectarse a tu base de datos. Antes de ejecutar tu secuencia de comandos, completa los siguientes pasos:

  1. En tu instancia de Google Cloud SQL, autoriza los rangos de IP, uno a la vez, desde esta fuente de datos.

  2. Copia la URL que se asignó a tu base de datos. Debe tener el formato jdbc:mysql:subname.

Una vez que hayas autorizado estos rangos de IP, crea conexiones a tu instancia de Cloud SQL de Google Cloud con uno de los métodos Jdbc.getConnection y la URL que copiaste antes.

Otras bases de datos

Si ya tienes tu propia base de datos de MySQL, Microsoft SQL Server, Oracle o PostgreSQL, conéctate a ella a través del servicio JDBC de Apps Script.

Crea otras conexiones de bases de datos

Para crear una conexión de base de datos con el servicio de JDBC de Apps Script, en la configuración de la base de datos, debes autorizar los rangos de IP de esta fuente de datos.

El servicio de JDBC solo se puede conectar a los puertos 1025 o posteriores. Asegúrate de que tu base de datos no esté publicando contenido desde un puerto inferior.

Una vez que se hayan establecido estas listas de entidades permitidas, crea una conexión a la base de datos con uno de los métodos Jdbc.getConnection y la URL de tu base de datos.

Código de muestra

En el siguiente código de muestra, se supone que te conectas a una base de datos de Google Cloud SQL y se crean conexiones de bases de datos con el método Jdbc.getCloudSqlConnection. Para otras bases de datos, debes usar el método Jdbc.getConnection para crear conexiones de bases de datos.

Para obtener más información sobre los métodos de JDBC, consulta la documentación de Java para JDBC.

Crea una base de datos, un usuario y una tabla

La mayoría de los desarrolladores usan la herramienta de línea de comandos de MySQL para crear bases de datos, usuarios y tablas. Sin embargo, es posible hacer lo mismo en Apps Script, como se muestra en el siguiente ejemplo. Crea al menos otro usuario para que tu secuencia de comandos no siempre tenga que conectarse a la base de datos como root.

service/jdbc.gs
/**
 * Create a new database within a Cloud SQL instance.
 */
function createDatabase() {
  try {
    const conn = Jdbc.getCloudSqlConnection(instanceUrl, root, rootPwd);
    conn.createStatement().execute(`CREATE DATABASE ${db}`);
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    console.log("Failed with an error %s", err.message);
  }
}

/**
 * Create a new user for your database with full privileges.
 */
function createUser() {
  try {
    const conn = Jdbc.getCloudSqlConnection(dbUrl, root, rootPwd);

    const stmt = conn.prepareStatement("CREATE USER ? IDENTIFIED BY ?");
    stmt.setString(1, user);
    stmt.setString(2, userPwd);
    stmt.execute();

    conn.createStatement().execute(`GRANT ALL ON \`%\`.* TO ${user}`);
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    console.log("Failed with an error %s", err.message);
  }
}

/**
 * Create a new table in the database.
 */
function createTable() {
  try {
    const conn = Jdbc.getCloudSqlConnection(dbUrl, user, userPwd);
    conn
      .createStatement()
      .execute(
        "CREATE TABLE entries " +
          "(guestName VARCHAR(255), content VARCHAR(255), " +
          "entryID INT NOT NULL AUTO_INCREMENT, PRIMARY KEY(entryID));",
      );
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    console.log("Failed with an error %s", err.message);
  }
}

Escribe en la base de datos

En los siguientes ejemplos, se muestra cómo escribir un solo registro en la base de datos y un lote de 500 registros. El procesamiento por lotes es fundamental para las operaciones masivas.

Se usan instrucciones parametrizadas, en las que las variables se indican con ?. Para evitar ataques de inyección de SQL, usa instrucciones con parámetros para escapar todos los datos proporcionados por el usuario.

service/jdbc.gs
/**
 * Write one row of data to a table.
 */
function writeOneRecord() {
  try {
    const conn = Jdbc.getCloudSqlConnection(dbUrl, user, userPwd);

    const stmt = conn.prepareStatement(
      "INSERT INTO entries " + "(guestName, content) values (?, ?)",
    );
    stmt.setString(1, "First Guest");
    stmt.setString(2, "Hello, world");
    stmt.execute();
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    console.log("Failed with an error %s", err.message);
  }
}

/**
 * Write 500 rows of data to a table in a single batch.
 */
function writeManyRecords() {
  try {
    const conn = Jdbc.getCloudSqlConnection(dbUrl, user, userPwd);
    conn.setAutoCommit(false);

    const start = new Date();
    const stmt = conn.prepareStatement(
      "INSERT INTO entries " + "(guestName, content) values (?, ?)",
    );
    for (let i = 0; i < 500; i++) {
      stmt.setString(1, `Name ${i}`);
      stmt.setString(2, `Hello, world ${i}`);
      stmt.addBatch();
    }

    const batch = stmt.executeBatch();
    conn.commit();
    conn.close();

    const end = new Date();
    console.log("Time elapsed: %sms for %s rows.", end - start, batch.length);
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    console.log("Failed with an error %s", err.message);
  }
}

/**
 * Write 500 rows of data to a table in a single batch.
 * Recommended for faster writes
 */
function writeManyRecordsUsingExecuteBatch() {
  try {
    const conn = Jdbc.getCloudSqlConnection(dbUrl, user, userPwd);
    conn.setAutoCommit(false);

    const start = new Date();
    const stmt = conn.prepareStatement(
      "INSERT INTO entries " + "(guestName, content) values (?, ?)",
    );
    const params = [];
    for (let i = 0; i < 500; i++) {
      params.push([`Name ${i}`, `Hello, world ${i}`]);
    }

    const batch = stmt.executeBatch(params);
    conn.commit();
    conn.close();

    const end = new Date();
    console.log("Time elapsed: %sms for %s rows.", end - start, batch.length);
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    console.log("Failed with an error %s", err.message);
  }
}

Realiza operaciones de lectura desde la base de datos

En este ejemplo, se muestra cómo leer una gran cantidad de registros de la base de datos y cómo iterar el conjunto de resultados según sea necesario.

service/jdbc.gs
/**
 * Read up to 1000 rows of data from the table and log them.
 */
function readFromTable() {
  try {
    const conn = Jdbc.getCloudSqlConnection(dbUrl, user, userPwd);
    const start = new Date();
    const stmt = conn.createStatement();
    stmt.setMaxRows(1000);
    const results = stmt.executeQuery("SELECT * FROM entries");
    const numCols = results.getMetaData().getColumnCount();

    while (results.next()) {
      let rowString = "";
      for (let col = 0; col < numCols; col++) {
        rowString += `${results.getString(col + 1)}\t`;
      }
      console.log(rowString);
    }

    results.close();
    stmt.close();

    const end = new Date();
    console.log("Time elapsed: %sms", end - start);
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    console.log("Failed with an error %s", err.message);
  }
}

/**
 * Read up to 1000 rows of data from the table and log them.
 * Recommended for faster reads
 */
function readFromTableUsingGetRows() {
  try {
    const conn = Jdbc.getCloudSqlConnection(dbUrl, user, userPwd);
    const start = new Date();
    const stmt = conn.createStatement();
    stmt.setMaxRows(1000);
    const results = stmt.executeQuery("SELECT * FROM entries");
    const numCols = results.getMetaData().getColumnCount();
    const getRowArgs = [];
    for (let col = 0; col < numCols; col++) {
      getRowArgs.push(`getString(${col + 1})`);
    }
    const rows = results.getRows(getRowArgs.join(","));
    for (let i = 0; i < rows.length; i++) {
      console.log(rows[i].join("\t"));
    }

    results.close();
    stmt.close();

    const end = new Date();
    console.log("Time elapsed: %sms", end - start);
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    console.log("Failed with an error %s", err.message);
  }
}

Cerrar conexiones

Las conexiones JDBC se cierran automáticamente cuando finaliza la ejecución de una secuencia de comandos. (Las llamadas de google.script.run únicas se consideran una ejecución completa, incluso si la página de servicio HTML que realizó la llamada permanece abierta).

Sin embargo, si sabes que terminaste de usar una conexión, una instrucción o un conjunto de resultados antes de que finalice la secuencia de comandos, ciérralos manualmente llamando a JdbcConnection.close, JdbcStatement.close o JdbcResultSet.close.

Mostrar un diálogo de alerta o mensaje también finaliza cualquier conexión JDBC abierta. Sin embargo, otros elementos de la IU que se muestran, como menús o diálogos personalizados y barras laterales con contenido personalizado, no lo hacen.

Google, Google Workspace y las marcas y los logotipos relacionados son marcas de Google LLC. Todos los demás nombres de productos y empresas son marcas comerciales de las empresas con las que se encuentran asociados.