JDBC

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Apps Script puede conectarse a bases de datos externas a través del servicio JDBC, un wrapper de la tecnología de Conectividad a bases de datos de Java estándar. El servicio de JDBC es compatible con las bases de datos de Google Cloud SQL MySQL, MySQL, Microsoft SQL Server y Oracle.

Para actualizar una base de datos externa con JDBC, la secuencia de comandos debe abrir una conexión a la base de datos y, luego, realizar cambios mediante el envío de instrucciones de SQL.

Bases de datos de Google Cloud SQL

Google Cloud SQL te permite crear bases de datos relacionales que se alojan en la nube de Google. Ten en cuenta que, a diferencia de Apps Script, Cloud SQL no es gratuito.

Puedes crear una instancia de Google Cloud SQL mediante los pasos que se enumeran en la Guía de inicio rápido de Cloud SQL.

Crea conexiones de Google Cloud SQL

Hay dos formas de establecer una conexión con una base de datos de Google Cloud SQL mediante el servicio JDBC de Apps Script:

Estos métodos se explican a continuación. Ambos son válidos, pero el segundo método requiere que enumeres 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 en Google Cloud SQL mediante el método Jdbc.getCloudSqlConnection(url). La URL de la base de datos tiene el formato jdbc:google:mysql://subname, en el que subname es el nombre de la conexión de la instancia de MySQL que aparece en la página Descripción general de la instancia de Cloud SQL en Google Cloud Platform Console.

Para conectarte a SQL Server de Cloud SQL, consulta Jdbc.getConnection(url).

Usa Jdbc.getConnection(url)

Para usar este método, debes incluir en la lista de entidades permitidas ciertos rangos de direcciones IP CIDR para que los servidores de Apps Script puedan conectarse a tu base de datos. Antes de ejecutar la secuencia de comandos, completa los siguientes pasos:

  1. En la 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 la base de datos. Debería tener el formato jdbc:mysql:subname.

Una vez que hayas agregado estos rangos de IP a la lista de direcciones permitidas, podrás crear conexiones a tu instancia de Google Cloud SQL mediante uno de los métodos Jdbc.getConnection(url) y la URL que copiaste antes.

Otras bases de datos

Si ya tienes una base de datos de MySQL, Microsoft SQL Server o Oracle, puedes conectarte a ella a través del servicio JDBC de Apps Script.

Crea otras conexiones de base de datos

Para crear una conexión de base de datos mediante el servicio JDBC, debes incluir ciertos rangos de IP en la configuración de tu base de datos para permitir que Apps Script acceda a ella. Estos son los rangos de direcciones que necesitarás para la lista de direcciones permitidas.

Una vez implementadas estas listas de permisos, puedes crear una conexión a la base de datos con uno de los métodos Jdbc.getConnection(url) y la URL de tu base de datos.

Ejemplo de código

El siguiente código de muestra supone que te estás conectando a una base de datos de Google Cloud SQL y crea conexiones de base de datos con el método Jdbc.getCloudSqlConnection(url). Para otras bases de datos, debes usar el método Jdbc.getConnection(url) a fin de crear conexiones de base de datos.

Si deseas 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 a continuación. Se recomienda crear al menos un usuario más para que la 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
    Logger.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
    Logger.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
    Logger.log('Failed with an error %s', err.message);
  }
}

Escribir en la base de datos

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

Además, ten en cuenta el uso de declaraciones con parámetros en las que las variables se denotan con ?. Para evitar las inyecciones de SQL, debes usar declaraciones con parámetros a fin de escapar de 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
    Logger.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();
    Logger.log('Time elapsed: %sms for %s rows.', end - start, batch.length);
  } catch (err) {
    // TODO(developer) - Handle exception from the API
    Logger.log('Failed with an error %s', err.message);
  }
}

Leer desde la base de datos

En este ejemplo, se muestra cómo leer una gran cantidad de registros de la base de datos y repetir 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';
      }
      Logger.log(rowString);
    }

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

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

Cierra conexiones

Las conexiones JDBC se cierran automáticamente cuando una secuencia de comandos termina de ejecutarse. (Ten en cuenta que una sola llamada a google.script.run cuenta como una ejecución completa, incluso si la página de servicio HTML que realizó la llamada permanece abierta).

Sin embargo, si sabes que terminaste con una conexión, una declaración o un conjunto de resultados antes del final de la secuencia de comandos, es una buena idea cerrarlos manualmente llamando a JdbcConnection.close(), JdbcStatement.close() o JdbcResultSet.close().

Si se muestra 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 personalizados o diálogos y barras laterales con contenido personalizado, no lo hacen.