du musst deinen "Rainbow" Effekt "nicht blockierend" programmieren.
Also keine Delays, keine tiefen For / Do / While schleifen
Dann können deine SQL Anfragen - zwar nicht parallel - aber so schnell hintereinander geschehen, dass es für dich fast wie parallel aussieht.
Dein Code in Code Tags inklusive anklickbarer Links zu all deinen verwendeten Libraries helfen uns dir besser zu helfen.
Aber vermutlich findest das auch selber: mit einer Suchmaschine
edit:
hab da in meinem Fundus was gefunden:
// Simple demonstration on using an input device to trigger changes on your
// NeoPixels. Wire a momentary push button to connect from ground to a
// digital IO pin. When the button is pressed it will change to a new pixel
// animation. Initial state has all pixels off -- press the button once to
// start the first animation. As written, the button does not interrupt an
// animation in-progress, it works only when idle.
// by noiasca
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif
// Digital IO pin connected to the button. This will be driven with a
// pull-up resistor so the switch pulls the pin to ground momentarily.
// On a high -> low transition the button press logic will execute.
constexpr byte buttonPin = A0; // was 2
constexpr byte pixelPin = 8; // Digital IO pin connected to the NeoPixels.
constexpr byte pixelCount = 16; // Number of NeoPixels (was 16)
// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(pixelCount, pixelPin, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 3 = Pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
boolean oldState = HIGH;
byte mode = 0; // Currently-active animation mode
bool active = true;
constexpr byte modeLast = 8;
void setup() {
Serial.begin(115200);
pinMode(buttonPin, INPUT_PULLUP);
strip.begin(); // Initialize NeoPixel strip object (REQUIRED)
strip.show(); // Initialize all pixels to 'off'
}
void loop() {
// Get current button state.
boolean newState = digitalRead(buttonPin);
// Check if state changed from high to low (button press).
if ((newState == LOW) && (oldState == HIGH)) {
// Short delay to debounce button.
delay(20);
// Check if button is still low after debounce.
newState = digitalRead(buttonPin);
if (newState == LOW) { // Yes, still low
if (++mode > modeLast) mode = 0; // Advance to next mode, wrap around after #8
Serial.print(F("mode=")); Serial.println(mode);
active = true; // activate the effect
}
}
// switch is now on top level, as we have to call the function over and over again
switch (mode) { // Start the new animation...
case 0:
colorWipe(strip.Color( 0, 0, 0), 50); // Black/off
break;
case 1:
colorWipe(strip.Color(255, 0, 0), 50); // Red
break;
case 2:
colorWipe(strip.Color( 0, 255, 0), 50); // Green
break;
case 3:
colorWipe(strip.Color( 0, 0, 255), 50); // Blue
break;
case 4:
theaterChase(strip.Color(127, 127, 127), 50); // White
break;
case 5:
theaterChase(strip.Color(127, 0, 0), 50); // Red
break;
case 6:
theaterChase(strip.Color( 0, 0, 127), 50); // Blue
break;
case 7:
rainbow(10);
break;
case 8:
theaterChaseRainbow(50);
break;
}
// Set the last-read button state to the old state.
oldState = newState;
}
// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, uint16_t wait) {
static uint32_t previousMillis = 0; // previous timestamp of change
static int i = 0; // former i from for loop
if (active && millis() - previousMillis > wait)
{
previousMillis = millis();
strip.setPixelColor(i, color); // Set pixel's color (in RAM)
strip.show(); // Update strip to match
if (i < strip.numPixels() - 1)
{
i++;
}
else
{
i = 0;
active = false; // this effect stopps
}
}
}
// Theater-marquee-style chasing lights. Pass in a color (32-bit value,
// a la strip.Color(r,g,b) as mentioned above), and a delay time (in ms)
// between frames.
void theaterChase(uint32_t color, int wait) {
static uint32_t previousMillis = 0;
static int a = 0;
static int b = 0;
if (active && millis() - previousMillis > wait)
{
previousMillis = millis();
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in steps of 3...
for (int c = b; c < strip.numPixels(); c += 3) {
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
if (++a >= 10) {
a = 0;
// active = false; // this effect runs endless
}
if (++b >= 3)
{
b = 0;
}
}
}
// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {
static uint32_t previousMillis = 0;
// Hue of first pixel runs 3 complete loops through the color wheel.
// Color wheel has a range of 65536 but it's OK if we roll over, so
// just count from 0 to 3*65536. Adding 256 to firstPixelHue each time
// means we'll make 3*65536/256 = 768 passes through this outer loop:
static long firstPixelHue = 0;
if (active && millis() - previousMillis > wait) {
for (int i = 0; i < strip.numPixels(); i++) { // For each pixel in strip...
// Offset pixel hue by an amount to make one full revolution of the
// color wheel (range of 65536) along the length of the strip
// (strip.numPixels() steps):
int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
// strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
// optionally add saturation and value (brightness) (each 0 to 255).
// Here we're using just the single-argument hue variant. The result
// is passed through strip.gamma32() to provide 'truer' colors
// before assigning to each pixel:
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
}
strip.show(); // Update strip with new contents
if (firstPixelHue < 3 * 65536)
{
firstPixelHue += 256;
}
else
{
firstPixelHue = 0;
//active = false; // this effect runs endless
}
}
}
// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {
static uint32_t previousMillis = 0;
static int a = 0; // Repeat 30 times...
static int b = 0; // 'b' counts from 0 to 2...
static int firstPixelHue = 0; // First pixel starts at red (hue 0)
strip.clear(); // Set all pixels in RAM to 0 (off)
if (active && millis() - previousMillis > wait)
{
previousMillis = millis();
// 'c' counts up from 'b' to end of strip in increments of 3...
for (int c = b; c < strip.numPixels(); c += 3) {
// hue of pixel 'c' is offset by an amount to make one full
// revolution of the color wheel (range 65536) along the length
// of the strip (strip.numPixels() steps):
int hue = firstPixelHue + c * 65536L / strip.numPixels();
uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGB
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
if (a < 30)
{
a++;
}
else
{ a = 0;
//active = false; // this effect runs endless
}
if (b < 3)
{
b++;
}
else
{
b = 0;
}
}
}
Ich finde nur nichts dazu...
ich frage, weil mir googeln leider nicht geholfen hat...
und leider auch nicht inwiefern der Code die Antwort auf meine Frage ist 
sorry 
da war meine Ursprungsfrage wohl etwas missverständlich...
aber auch wenn ich es nicht verstehe, radel ich jetzt mal in den Makerspace (da habe ich meine Buttons zum Ausprobieren 
und es funktioniert!