dxdc / aws-sdk-google-apps Goto Github PK

(require,module,exports){"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=function(){if(!getRandomValues)throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return getRandomValues(rnds8)};var getRandomValues="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto),rnds8=new Uint8Array(16)},{}],120:[function(require,module,exports){"use strict";function f(s,x,y,z){switch(s){case 0:return x&y^~x&z;case 1:return x^y^z;case 2:return x&y^x&z^y&z;case 3:return x^y^z}}function ROTL(x,n){return x<<n|x>>>32-n}Object.defineProperty(exports,

const { AthenaClient, StartQueryExecutionCommand, GetQueryExecutionCommand, GetQueryResultsCommand } = require('@aws-sdk/client-athena');

async function runAthenaQuery(athenaClient, database, query, outputLocation) {

  const queryExecutionParams = {
    QueryString: query,
    QueryExecutionContext: {
      Database: database,
    },
    ResultConfiguration: {
      OutputLocation: outputLocation,
    },
  };

  const startQueryExecutionCommand = new StartQueryExecutionCommand(queryExecutionParams);

  try {
    const queryExecutionResponse = await athenaClient.send(startQueryExecutionCommand);
    const queryExecutionId = queryExecutionResponse.QueryExecutionId;
    console.log("Query submitted. Execution ID:", queryExecutionId);
    return queryExecutionId;
  } catch (error) {
    console.error("Error executing Athena query:", error);
    throw error;
  }
}

function getQueryResultsWithPolling(athenaClient, queryId) {
  return new Promise((resolve, reject) => {
    const interval = setInterval(() => {
      const queryExecutionParams = { QueryExecutionId: queryId };
      const getQueryExecutionCommand = new GetQueryExecutionCommand(queryExecutionParams);

      athenaClient.send(getQueryExecutionCommand)
        .then((response) => {
          const status = response.QueryExecution.Status.State;
          console.log(`Query execution status: ${status}`);

          if (status === 'SUCCEEDED') {
            clearInterval(interval);

            const getQueryResultsParams = { QueryExecutionId: queryId };
            const getQueryResultsCommand = new GetQueryResultsCommand(getQueryResultsParams);

            return athenaClient.send(getQueryResultsCommand);
          } else if (status === 'FAILED' || status === 'CANCELLED') {
            clearInterval(interval);
            reject(new Error(`Query execution failed or cancelled. Status: ${status}`));
          }
        })
        .then((resultResponse) => {
          resolve(resultResponse);
        })
        .catch((error) => {
          clearInterval(interval);
          reject(error);
        });
    }, 2000);
  });
}

function executeAthenaQuery(database, query, outputLocation, awsRegion, awsAccessKeyId, awsSecretAccessKey) {
  const awsCredentials = {
    accessKeyId: awsAccessKeyId,
    secretAccessKey: awsSecretAccessKey,
  };
  
  const athena = new AthenaClient({
    region: awsRegion,
    credentials: awsCredentials,
  });

  return new Promise(async (resolve, reject) => {
    try {
      const queryId = await runAthenaQuery(athena, database, query, outputLocation, awsRegion, awsAccessKeyId, awsSecretAccessKey);
      console.log('Query ID:', queryId);

      const queryResults = await getQueryResultsWithPolling(athena, queryId);
      console.log('Query Results:', queryResults);

      resolve(queryResults);
    } catch (error) {
      console.error('Error:', error);
      reject(error);
    }
  });
}