# ZCQL -------------------------------------------------------------------------------- title: "" last_updated: "2026-07-30T07:10:05.692Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/zcql-console/" -------------------------------------------------------------------------------- ? --- title: "La consola de ZCQL" page_type: "home" service: "Cloud Scale" description: "ZCQL es el lenguaje de consulta propio de Catalyst, inspirado en lenguajes de consulta conocidos, que puedes utilizar para consultar la base de datos de tu aplicación de manera eficiente." tags : [ " " ] type: "general" parent_path : "/es/cloud-scale/help/" weight: 13 name: "ZCQL" --- # La consola de ZCQL La **consola de ZCQL** es una herramienta intuitiva que te permite ejecutar las consultas ZCQL que necesites, realizar operaciones de manipulación de datos almacenados en el Data Store y guardar las consultas ZCQL requeridas directamente en la consola de Catalyst. ### Características principales <br /> La *consola de ZCQL* te ofrece las siguientes funcionalidades: * Cuando escribes una consulta, se te proporciona una sugerencia de autocompletado relevante y significativa que te permite formar tus consultas de manera fácil y rápida. * Ejecuta cualquier consulta en la consola y visualiza directamente la salida completa. * Copia la consulta usando el *botón de copiar* y aplícala a tu código con facilidad. * Guarda cualquiera de tus consultas ZCQL requeridas y reutilízala cuando sea necesario. * Usando el **ZCQL Explorer**, puedes buscar y reutilizar fácilmente la consulta guardada que necesites, ver la información de columnas de todas las tablas creadas en el proyecto y también reutilizar consultas ejecutadas previamente desde la sección *History*. Nota: * De forma predeterminada, solo se pueden guardar 50 consultas ZCQL en un único proyecto de Catalyst. Si necesitas un límite mayor, puedes contactar al equipo de soporte de Catalyst para aumentar este umbral. * Solo las últimas 100 consultas ZCQL se registrarán en la sección History del ZCQL Explorer. Sin embargo, no hay límite de tiempo sobre cuánto tiempo estará disponible la consulta en History. ### Acceder a la consola de ZCQL Para acceder a la consola de ZCQL:<span></span> 1. Navega al componente **Data Store** presente en la sección *STORAGE* del servicio CloudScale. <br /> Nota: Necesitas crear una tabla en el Data Store para poder acceder a la consola de ZCQL. 2. Haz clic en la pestaña **ZCQL Console**. <br /> Puedes escribir tu consulta en esta consola y realizar las operaciones requeridas. ### El ZCQL Explorer El *ZCQL Explorer* es una funcionalidad expandible y contraíble de la consola de ZCQL. Contiene las siguientes secciones: * **Schema**: Schema contiene información sobre la tabla que incluye la lista de columnas presentes en la tabla, si el valor de las columnas es obligatorio y el tipo de dato que se almacenará en estas columnas. <br /> * **Saved Queries**: Esta sección contendrá una lista de todas las consultas que hayas guardado usando el botón **Save Query**. Puedes buscar la consulta que necesites por su nombre y reutilizarla. <br /> Nota: De forma predeterminada, solo se pueden guardar 50 consultas ZCQL en un único proyecto de Catalyst. Si necesitas un límite mayor, puedes contactar al equipo de soporte de Catalyst para aumentar este umbral. * **History**: La sección *History* contendrá la lista completa de las **últimas 100 consultas** que se han ejecutado en la consola. <br /> Si deseas guardar una consulta de la sección *History*, haz clic en el **ícono de guardar** junto a la consulta requerida y sigue los pasos indicados en esta [sección](#SaveaZCQLQuery). Nota: Solo las últimas 100 consultas ZCQL estarán presentes en la sección History. Sin embargo, no hay límite de tiempo sobre cuánto tiempo se puede almacenar la consulta en History. ### Ejecutar una consulta ZCQL Para ejecutar una consulta ZCQL en la consola de ZCQL: 1. Ingresa tu consulta ZCQL en la consola. <br /> 2. Haz clic en el botón **Execute Query**. <br /> Podrás visualizar la salida directamente en la consola. La consulta se ejecutará y se registrará en la sección *History* presente en el **ZCQL Explorer**. De forma predeterminada, verás la salida en *Table View*. También tienes la opción de ver la salida como JSON haciendo clic en el menú desplegable **View** y seleccionando la opción **JSON View**. <br /> También tienes la opción de copiar este JSON y usarlo según sea necesario. ### Guardar una consulta ZCQL En la consola de ZCQL, puedes ejecutar las consultas que necesites y guardarlas. Guardar tus consultas te permite recuperarlas fácilmente y usarlas cuando sea necesario en lugar de ingresarlas manualmente en cada sesión. Nota: De forma predeterminada, solo se pueden guardar 50 consultas ZCQL en un único proyecto de Catalyst. Si necesitas un límite mayor, puedes contactar al equipo de soporte de Catalyst para aumentar este umbral. Para guardar una consulta ZCQL: 1. Ingresa la consulta que necesites y haz clic en el botón **Save Query**. <br /> 2. En la ventana emergente, revisa la sección *Query Preview*, proporciona un **Query Name** para identificar tu consulta y haz clic en **Save**. <br /> Tu consulta se guardará. Puedes ver y gestionar tus consultas desde la sección *ZCQL Explorer*, en la pestaña **Saved Queries**. <br /> Puedes hacer clic en el botón *Console* para imprimir la consulta en tu consola. <br /> También puedes editar esta consulta y ejecutarla según sea necesario, o guardarla con un nombre de consulta diferente repitiendo los pasos mencionados anteriormente. ### Eliminar una consulta guardada Para eliminar una consulta guardada: 1. Haz clic en el **ícono de eliminar** presente junto a la consulta requerida en la sección **Saved Queries** del *ZCQL Explorer*. <br /> 2. Haz clic en **Yes, Proceed** en la ventana emergente de confirmación para eliminar la consulta requerida. <br /> La consulta se eliminará. ### Usar ZCQL V2 en código de Functions Para usar código de **ZCQL V2** en tu función, necesitarás configurar una variable de entorno de la siguiente manera: 1. Navega a *Serverless* > **Functions**. <br /> 2. Haz clic en la función que contiene tu código de ZCQL V2. 3. Haz clic en la pestaña **Configuration**, luego haz clic en **Create Variable** en *Environmental Variables*. <br /> 4. Ingresa los siguientes valores en los campos correspondientes:<br />**Key**: ZOHO_CATALYST_ZCQL_PARSER<br />**Development Value**: V2 <br /> 5. Haz clic en **Save**. <br /> Ahora podrás usar ZCQL V2 en el código de tu función. Nota: * No necesitas referenciar la variable de entorno en ninguna parte de tu código. Una vez que la hayas configurado en la consola, puedes usar ZCQL V2 en el código de tu función. * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus organizaciones presentes en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser en el entorno de producción, si y cuando se habilite producción para el proyecto. -------------------------------------------------------------------------------- title: "Introducción" description: "ZCQL es el lenguaje de consulta propio de Catalyst, modelado a partir de lenguajes de consulta familiares, que puedes usar para consultar la base de datos de tu aplicación de forma eficiente." last_updated: "2026-07-30T07:10:05.695Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/introduction/" service: "Cloud Scale" -------------------------------------------------------------------------------- # ZCQL ## Introducción Catalyst Cloud Scale ZCQL sirve como el lenguaje de consulta propio de Catalyst, similar a MySQL o PostgreSQL. Se utiliza para realizar manipulaciones de datos dentro del Catalyst Data Store. Como motor de consultas impulsado por Catalyst, ZCQL permite a los desarrolladores trabajar con datos usando una sintaxis familiar similar a SQL mientras maneja consultas complejas con alta eficiencia y escalabilidad. Puedes realizar las siguientes operaciones en las tablas de tu Data Store usando ZCQL: * Recuperación: Obtener registros de tablas existentes * Inserción: Insertar registros en las columnas existentes de una tabla existente * Actualización: Actualizar el valor de columnas existentes en una tabla existente * Eliminación: Eliminar registros de una tabla existente Puedes ejecutar una variedad de consultas DML usando ZCQL para obtener o manipular datos basándote en criterios específicos utilizando diversas cláusulas y sentencias como las cláusulas SQL Join, las sentencias Groupby, las sentencias OrderBy, y las cláusulas WHERE y HAVING. ZCQL también admite varias funciones numéricas SQL integradas que te ayudan a ejecutar operaciones aritméticas fácilmente. Puedes implementar consultas ZCQL en el código fuente de tu aplicación Catalyst, como en las funciones o el componente Client. Por ejemplo, puedes pasar una consulta ZCQL en el cuerpo de una función para recuperar datos de una tabla en el Data Store y procesarlos posteriormente. La consola de Catalyst también proporciona una ventana de ejecución de consultas ZCQL, donde puedes ejecutar consultas y ver las respuestas. Esto te permite probar consultas ZCQL fácilmente, antes de implementarlas en tu aplicación. ### Documentación de SDK y API Catalyst ofrece ZCQL en los paquetes de SDK de Java, Node.js, Python, Web, Android, iOS y Flutter, y como API. Para ejemplos de código sobre la ejecución de consultas ZCQL en estos entornos de programación, consulta estas páginas de ayuda: * Execute ZCQL Query - Java SDK * Execute ZCQL Query - Node.js SDK * Execute ZCQL Query - Python SDK * Execute ZCQL Query - Web SDK * Execute ZCQL Query - Android SDK * Execute ZCQL Query - iOS SDK * Execute ZCQL Query - Flutter SDK * Execute ZCQL Query - API Nota: * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus Organizaciones presentes en el Entorno de Desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las Organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el Entorno de Desarrollo se mapearán automáticamente al ZCQL V2 Parser en el Entorno de Producción, si y cuando se habilite la producción para el proyecto. * Para usar ZCQL V2 en tu código, necesitas establecer la variable de entorno apropiada como se muestra en este documento de ayuda. Puedes consultar los Tutoriales de Catalyst para obtener una idea de la implementación de ZCQL en el código de funciones o Client de las aplicaciones. ### Beneficios * Puede realizar operaciones de recuperación, inserción, actualización y eliminación de datos en el Catalyst Data Store * La similitud con MySQL garantiza facilidad de uso y no hay una curva de aprendizaje separada * Se puede probar la ejecución de las consultas en la consola antes de implementarlas en la aplicación * Se puede pasar una consulta ZCQL en el cuerpo de una API usando los SDKs * Se pueden realizar operaciones aritméticas y numéricas en el conjunto de resultados usando las funciones integradas de ZCQL -------------------------------------------------------------------------------- title: "Sintaxis General de SELECT" description: "ZCQL es el lenguaje de consulta propio de Catalyst, modelado a partir de lenguajes de consulta familiares, que puedes usar para consultar la base de datos de tu aplicación de forma eficiente." last_updated: "2026-07-30T07:10:05.696Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/select/" service: "Cloud Scale" -------------------------------------------------------------------------------- # SELECT ### Sintaxis General de SELECT ZCQL admite operaciones de consulta de recuperación de datos usando el comando SELECT. Este comando te permite seleccionar una columna o un conjunto de columnas de una tabla base y ver los registros de datos dentro del alcance del comando. La sintaxis general para una operación básica de recuperación de datos en ZCQL es la siguiente: SELECT {COLUMNS} FROM {BASE_TABLE_NAME} [JOIN_CLAUSE] [WHERE {WHERE_CONDITION}] [GROUP BY {GROUP_BY_COLUMN}] [ORDER BY {ORDER_BY_COLUMN}] LIMIT [{OFFSET}],{VALUE} <br /> Nota:<br /> * La tabla base es la tabla sobre la que ejecutas la consulta. * No necesitas usar el delimitador de fin de sentencia (;) al final de una consulta ZCQL al ejecutarla en la consola de ZCQL. La tabla base es la tabla sobre la que ejecutas la consulta. Analizaremos cada operación de ZCQL en detalle con una base de datos de ejemplo y consultas de muestra que puedes ejecutar en ella. Base de datos de ejemplo: Imagina que estás desarrollando una aplicación de reserva de entradas donde los usuarios pueden ver los listados de películas y horarios de funciones de varios teatros en una ciudad, y pueden reservar entradas de cine usando la aplicación. Creemos una tabla llamada 'Movies' que contenga los listados de horarios de las películas que se proyectan en varios teatros. A continuación se muestran registros de ejemplo de la tabla _Movies_: <table class="content-table"> <thead> <tr> <th><strong>MovieID</strong></th> <th><strong>MovieName</strong></th> <th><strong>ShowDate</strong></th> <th><strong>ShowTime</strong></th> <th><strong>TheaterID</strong></th> </tr> </thead> <tbody> <tr> <td>2056</td> <td>The First Purge</td> <td>2018-07-13</td> <td>13:00:00</td> <td>047</td> </tr> <tr> <td>2057</td> <td>Ant-Man and the Wasp</td> <td>2018-07-13</td> <td>14:20:00</td> <td>052</td> </tr> <tr> <td>2058</td> <td>Hotel Transylvania 3: Summer Vacation</td> <td>2018-07-14</td> <td>17:00:00</td> <td>052</td> </tr> <tr> <td>2059</td> <td>Skyscraper</td> <td>2018-07-14</td> <td>21:30:00</td> <td>053</td> </tr> </tbody> </table> <br /> ### SELECT Básico La sentencia SELECT se usa para seleccionar las columnas de una tabla base y mostrar sus registros. Debes mencionar los nombres de las columnas que se mostrarán en el conjunto de resultados. La sintaxis para usar una sentencia SELECT básica es: SELECT column_name(s) FROM base_table_name <br /> Ejemplo: Para seleccionar las columnas _MovieID_ y _MovieName_ de la tabla _Movies_, ejecuta la siguiente consulta: SELECT MovieID, MovieName from Movies <br /> Generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>MovieID</strong></th> <th><strong>MovieName</strong></th> </tr> </thead> <tbody> <tr> <td>2056</td> <td>The First Purge</td> </tr> <tr> <td>2057</td> <td>Ant-Man and the Wasp</td> </tr> <tr> <td>2058</td> <td>Hotel Transylvania 3: Summer Vacation</td> </tr> <tr> <td>2059</td> <td>Skyscraper</td> </tr> </tbody> </table> <br /> Para columnas que han sido nombradas usando números enteros, necesitas agregar la puntuación de acento grave **`** para diferenciar entre el nombre de la columna y el valor. Por ejemplo, una consulta SELECT en una tabla llamada *Numbers* con una columna llamada *01* se puede escribir de la siguiente manera SELECT `01` FROM Numbers<br /> Nota: Puedes obtener un máximo de 20 columnas y un máximo de 300 filas en una consulta SELECT. Si necesitas obtener más registros, puedes usar la cláusula LIMIT para iterar la consulta y especificar el offset y el valor correspondientemente. <br /> ### SELECT \* Puedes obtener registros de todas las columnas de una tabla base, en lugar de seleccionar registros de una columna o columnas particulares, usando un '\*' después de la sentencia SELECT. El '\*' denota todas las columnas de la tabla base. La sintaxis para seleccionar todas las columnas de una tabla base es: SELECT * FROM base_table_name <br /> Nota: SELECT \* te permite obtener un máximo de 300 filas en una consulta. Si necesitas obtener más registros, puedes usar la cláusula LIMIT para iterar la consulta y especificar el offset y el valor correspondientemente. Ejemplo: Para mostrar los registros de todas las columnas de la tabla _Movies_, ejecuta la siguiente consulta: SELECT * FROM Movies Esto mostrará los registros de todas las columnas en la tabla _Movies_. <table class="content-table"> <thead> <tr> <th><strong>MovieID</strong></th> <th><strong>MovieName</strong></th> <th><strong>ShowDate</strong></th> <th><strong>ShowTime</strong></th> <th><strong>TheaterID</strong></th> </tr> </thead> <tbody> <tr> <td>2056</td> <td>The First Purge</td> <td>2018-07-13</td> <td>13:00:00</td> <td>047</td> </tr> <tr> <td>2057</td> <td>Ant-Man and the Wasp</td> <td>2018-07-13</td> <td>14:20:00</td> <td>052</td> </tr> <tr> <td>2058</td> <td>Hotel Transylvania 3: Summer Vacation</td> <td>2018-07-14</td> <td>17:00:00</td> <td>052</td> </tr> <tr> <td>2059</td> <td>Skyscraper</td> <td>2018-07-14</td> <td>21:30:00</td> <td>053</td> </tr> </tbody> </table> -------------------------------------------------------------------------------- title: "Sintaxis General de INSERT" description: "ZCQL es el lenguaje de consulta propio de Catalyst, modelado a partir de lenguajes de consulta familiares, que puedes usar para consultar la base de datos de tu aplicación de forma eficiente." last_updated: "2026-07-30T07:10:05.698Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/insert/" service: "Cloud Scale" -------------------------------------------------------------------------------- # INSERT ### Sintaxis General de INSERT Puedes insertar un registro en una tabla pasando los valores para cada columna de esa tabla para ese registro. La sintaxis general de una operación básica de inserción de datos en ZCQL es la siguiente: INSERT INTO {BASE_TABLE_NAME} VALUES (VALUE1, VALUE2,..) Debes pasar los valores en el mismo orden en que las columnas están presentes en la tabla. Nota:<br /> * Asegúrate de proporcionar el valor correcto para una columna que coincida con el tipo de dato de la columna. * Para las columnas donde la restricción _IsUnique_ está habilitada, asegúrate de no ingresar valores que ya estén presentes en otros registros. De manera similar, para las columnas donde el validador _IsMandatory_ está habilitado, asegúrate de no dejar el valor de datos en blanco. * Para una columna donde el tipo de dato es una Foreign Key, debes proporcionar el ROWID del registro de la tabla padre al que hace referencia, como su valor. Ejemplo: Para insertar un registro en la tabla _Movies_, ejecuta la siguiente consulta: INSERT INTO Movies VALUES (2060,'Mission: Impossible – Fallout', '2018-7-27', '16:00:00', 053) Nota: Si los valores a insertar son valores de tipo String, debes pasar los valores encerrados entre comillas simples como se muestra arriba. ### Inserción Parcial También puedes pasar valores solo para columnas específicas en una tabla especificando los nombres de las columnas para las cuales se necesitan insertar los valores. La sintaxis para una inserción parcial es la siguiente: INSERT INTO {BASE_TABLE_NAME} (COLUMN_NAME1, COLUMN_NAME2,..) VALUES (VALUE1, VALUE2,..) Para insertar un registro y pasar valores solo para las columnas _MovieID_ y _TheaterID_ en la tabla _Movies_, ejecuta la siguiente consulta: INSERT INTO Movies (MovieID, TheaterID) VALUES (2061, 052) -------------------------------------------------------------------------------- title: "Sintaxis General de UPDATE" description: "ZCQL es el lenguaje de consulta propio de Catalyst, modelado a partir de lenguajes de consulta familiares, que puedes usar para consultar la base de datos de tu aplicación de forma eficiente." last_updated: "2026-07-30T07:10:05.698Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/update/" service: "Cloud Scale" -------------------------------------------------------------------------------- # UPDATE ### Sintaxis General de UPDATE El comando UPDATE te permite actualizar valores de columnas específicos de registros existentes de una tabla en el Data Store. Puedes actualizar los valores de las columnas basándote en ciertas condiciones. Estas condiciones se pueden especificar usando la cláusula WHERE, que analizaremos más adelante en detalle. La sintaxis general de una operación básica de actualización de datos en ZCQL es la siguiente: UPDATE {BASE_TABLE_NAME} SET {COLUMN_NAME}={VALUE}[WHERE {WHERE_CONDITION}] Nota:<br /> * Asegúrate de proporcionar el valor correcto para una columna que coincida con el tipo de dato de la columna. * Para las columnas donde la restricción _IsUnique_ está habilitada, asegúrate de no ingresar valores que ya estén presentes en otros registros. De manera similar, para las columnas donde el validador _IsMandatory_ está habilitado, asegúrate de no dejar el valor de datos en blanco. * Para una columna donde el tipo de dato es una Foreign Key, debes proporcionar el ROWID del registro de la tabla padre al que hace referencia, como su valor. Ejemplo: Para actualizar el valor de un nombre de película específico referido por su _MovieID_ en la tabla _Movies_, ejecuta la siguiente consulta: UPDATE Movies SET MovieName='The Equalizer 2'WHERE MovieID=2056 <br /> -------------------------------------------------------------------------------- title: "Sintaxis General de DELETE" description: "ZCQL es el lenguaje de consulta propio de Catalyst, modelado a partir de lenguajes de consulta familiares, que puedes usar para consultar la base de datos de tu aplicación de forma eficiente." last_updated: "2026-07-30T07:10:05.699Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/delete/" service: "Cloud Scale" -------------------------------------------------------------------------------- # DELETE ### Sintaxis General de DELETE El comando DELETE te permite eliminar uno o más registros de una tabla de forma permanente. Puedes indicar los registros a eliminar usando la cláusula WHERE, que se explica en la siguiente sección, y especificar las condiciones. La sintaxis general de una sentencia DELETE básica es la siguiente: DELETE FROM {BASE_TABLE_NAME}[WHERE {WHERE_CONDITION}] Ejemplo: Para eliminar el registro de una fecha de función específica en un teatro particular de la tabla Movies, puedes ejecutar esta consulta: DELETE FROM Movies WHERE MovieID=2059 AND ShowDate='2018-07-14' AND TheaterID=053 <br /> -------------------------------------------------------------------------------- title: "Cláusula WHERE" description: "ZCQL es el lenguaje de consulta propio de Catalyst, inspirado en lenguajes de consulta conocidos, que puedes utilizar para consultar la base de datos de tu aplicación de manera eficiente." last_updated: "2026-07-30T07:10:05.699Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/where/" service: "Cloud Scale" -------------------------------------------------------------------------------- # Cláusula WHERE ### Introducción La cláusula WHERE se utiliza para filtrar los registros de datos en función de una condición especificada o un conjunto de condiciones en las consultas de búsqueda. Cuando se usa la condición WHERE en una consulta, los registros de datos se verifican según las condiciones especificadas y los comandos se ejecutan solo en los registros que satisfacen las condiciones. Por ejemplo, la sintaxis para usar la condición WHERE en una sentencia SELECT es: SELECT column_name(s) FROM base_table_name WHERE condition La condición WHERE también se puede usar con las sentencias UPDATE y DELETE. <br /> ### Operadores soportados por la cláusula WHERE Puedes usar los siguientes operadores en las condiciones WHERE en consultas ZCQL: <table class="content-table"> <thead> <tr> <th class="w30p"><strong>Operadores</strong></th> <th class="w70p"><strong>Descripción</strong></th> </tr> </thead> <tbody> <tr> <td>=</td> <td>Igual a</td> </tr> <tr> <td>IS</td> <td>TRUE si el operando es igual al valor</td> </tr> <tr> <td>IS NULL</td> <td>TRUE si el operando es un valor nulo</td> </tr> <tr> <td>IS NOT NULL</td> <td>TRUE si el operando no es un valor nulo</td> </tr> <tr> <td>!=</td> <td>No igual a</td> </tr> <tr> <td>LIKE</td> <td>TRUE si el operando coincide con un patrón</td> </tr> <tr> <td>NOT LIKE</td> <td>TRUE si el operando no coincide con un patrón</td> </tr> <tr> <td>BETWEEN</td> <td>TRUE si el valor del operando está entre los valores de inicio y fin</td> </tr> <tr> <td>IN</td> <td>TRUE si el operando es igual a una lista de expresiones</td> </tr> <tr> <td>NOT IN</td> <td>TRUE si el operando no es igual a una lista de expresiones</td> </tr> <tr> <td>&gt;</td> <td>Mayor que</td> </tr> <tr> <td>&gt;=</td> <td>Mayor o igual que</td> </tr> <tr> <td>&lt;</td> <td>Menor que</td> </tr> <tr> <td>&lt;=</td> <td>Menor o igual que</td> </tr> </tbody> </table> <br /> Ejemplo: Para ver una lista de las películas que se proyectan en días distintos al 13 de julio de 2018 de la tabla Movies, puedes especificar la condición de fecha en la consulta usando la cláusula WHERE de la siguiente manera: SELECT MovieName, ShowDate FROM Movies WHERE ShowDate IS '2018-07-14' Esto generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>MovieName</strong></th> <th><strong>ShowDate</strong></th> </tr> </thead> <tbody> <tr> <td>Hotel Transylvania 3: Summer Vacation</td> <td>2018-07-14</td> </tr> <tr> <td>Skyscraper</td> <td>2018-07-14</td> </tr> </tbody> </table> <br /> ### Múltiples condiciones WHERE Puedes especificar un máximo de cinco condiciones WHERE en una sola consulta. Cuando se especifican múltiples condiciones WHERE, puedes usar un operador AND o OR para vincular las condiciones entre sí. Las funcionalidades de los operadores AND y OR son: * AND: Produce solo los registros de datos que satisfacen ambas condiciones asociadas con el operador AND. * OR: Produce los registros de datos que satisfacen cualquiera de las condiciones asociadas con el operador OR. Por ejemplo, la sintaxis para usar múltiples condiciones WHERE en una sentencia SELECT es: SELECT column_name(s) FROM base_table_name WHERE condition_1 AND|OR condition_2.. AND|OR condition_5 Ejemplo: Para ver una lista de las fechas y horarios de proyección de la tabla _Movies_ para las películas 'The First Purge' o 'Skyscraper' que se proyectan el 14 de julio, ejecuta la siguiente consulta: SELECT MovieName, ShowDate, ShowTime FROM Movies WHERE MovieName='The First Purge' OR MovieName='Skyscraper' AND ShowDate='2018-07-14' Solo hay un registro que coincide con las condiciones anteriores. Por lo tanto, la consulta generará el siguiente resultado: <table class="content-table"> <thead> <tr> <th><strong>MovieName</strong></th> <th><strong>ShowDate</strong></th> <th><strong>ShowTime</strong></th> </tr> </thead> <tbody> <tr> <td>Skyscraper</td> <td>2018-07-14</td> <td>21:30:00</td> </tr> </tbody> </table> <br /> ### Sentencia LIKE La condición LIKE te permite indicar registros que contienen un criterio específico y seleccionar todos los registros que coincidan con esa condición. Por ejemplo, puedes indicar un alfabeto específico con el que deben comenzar los registros que necesitas obtener, o un valor particular que deben contener. Por ejemplo, la sintaxis de la condición LIKE en una sentencia UPDATE es la siguiente: UPDATE base_table_name SET column_name(s)=value(s) WHERE condition LIKE *value* El '\*' se puede usar antes o después, o tanto antes como después, del valor que especifiques. El '\*' es esencialmente un marcador de posición que indica que cualquier valor puede reemplazarse en su lugar. Por ejemplo, para indicar que se deben obtener todos los registros de una tabla que comienzan con la letra 'A', puedes ingresar el valor de LIKE como 'A\*'. Esto especifica que después de la letra A, cualquier valor puede seguir. Ejemplo: Para actualizar los registros donde los nombres de películas comienzan con la letra 'S' en la tabla _Movies_, ejecuta la siguiente consulta: UPDATE Movies SET ShowDate='2018-07-17' WHERE MovieName like 'S*' Esto actualizará el siguiente registro y establecerá el valor: <table class="content-table"> <thead> <tr> <th><strong>MovieID</strong></th> <th><strong>MovieName</strong></th> <th><strong>ShowDate</strong></th> <th><strong>ShowTime</strong></th> <th><strong>TheaterID</strong></th> </tr> </thead> <tbody> <tr> <td>2059</td> <td>Skyscraper</td> <td>2018-07-17</td> <td>21:30:00</td> <td>053</td> </tr> </tbody> </table> <br /> También se permite el uso de sintaxis de comodines y símbolos como \* y ? en las sentencias ZCQL definidas usando la sentencia de condición LIKE. <table class="content-table"> <thead> <tr> <th class="w30p">Sintaxis de comodín</th> <th class="w70p">Definición</th> </tr> </thead> <tbody> <tr> <td>\*</td> <td>Coincide con cero o más caracteres</td> </tr> <tr> <td>?</td> <td>Coincide con exactamente un carácter</td> </tr> </tbody> </table> ### Sentencia BETWEEN La condición BETWEEN te permite filtrar registros indicando los valores de inicio y fin en una columna particular que contiene valores numéricos. Por ejemplo, puedes seleccionar todos los registros donde los valores de porcentaje estén entre 70 y 80. Por ejemplo, la sintaxis de una condición BETWEEN en una sentencia DELETE es la siguiente: DELETE FROM base_table_name WHERE condition BETWEEN Value1 AND Value2 <br /> Nota: Solo puedes usar la sentencia BETWEEN para seleccionar valores 'Int' o 'Double' en la tabla del Data Store de Catalyst. No podrás usarla para ningún otro tipo de dato. Ejemplo: Para eliminar los registros donde el valor de MovieID está entre 2056 y 2059 en la tabla _Movies_, ejecuta la siguiente consulta: DELETE FROM Movies WHERE MovieID BETWEEN 2056 AND 2059 Los siguientes registros de la tabla se eliminarán: <table class="content-table"> <thead> <tr> <th><strong>MovieID</strong></th> <th><strong>MovieName</strong></th> <th><strong>ShowDate</strong></th> <th><strong>ShowTime</strong></th> <th><strong>TheaterID</strong></th> </tr> </thead> <tbody> <tr> <td>2057</td> <td>Ant-Man and the Wasp</td> <td>2018-07-13</td> <td>14:20:00</td> <td>052</td> </tr> <tr> <td>2058</td> <td>Hotel Transylvania 3: Summer Vacation</td> <td>2018-07-14</td> <td>17:00:00</td> <td>052</td> </tr> </tbody> </table> Nota: Para producir el resultado exactamente opuesto, puedes usar la sentencia NOT BETWEEN. La misma sintaxis y condiciones de una sentencia BETWEEN se aplican a las sentencias NOT BETWEEN. <br /> ### Comparación de columna a columna Puedes comparar dos columnas de la misma tabla o de tablas diferentes **haciendo referencia a los nombres de las columnas con sus respectivos nombres de tabla** en el lado izquierdo y derecho de la comparación. El resultado de la comparación devolverá las filas que contengan el mismo valor para column1 y column2 en la tabla. Esta compatibilidad de comparación en la cláusula WHERE es aplicable a las consultas SELECT, UPDATE y DELETE. Puedes comparar dos columnas cualesquiera que sean de los siguientes tipos de datos: BOOLEAN, DOUBLE, DATE, DATETIME, ENCRYPTED, VARCHAR, TEXT, INT y BIGINT. Nota: No puedes comparar columnas de dos tipos de datos diferentes. <br /> **SELECT:** La sintaxis general para la comparación de columnas dentro de la misma tabla es la siguiente: SELECT * FROM tablename WHERE columnname1 = tablename.columnname2 **Ejemplo**:<br /> Select MovieName FROM Movies WHERE Actor = Movies.Producer <table class="content-table" style="width:30%"> <thead> <tr> <th>MovieName</th> </tr> </thead> <tbody> <tr> <td>The White River Kid</td> </tr> <tr> <td>Duplex</td> </tr> <tr> <td>Oppenheimer</td> </tr> </tbody> </table> **UPDATE:** UPDATE Movies SET self_produced = "Yes" WHERE Actor = Movies.Producer **DELETE:** DELETE FROM Movies WHERE Actor = Movies.Producer <br /> #### Comparación de columnas en tablas diferentes También puedes comparar columnas de dos tablas diferentes como se muestra en la siguiente sintaxis: SELECT tablename1.columnname1, tablename2.columnname1 FROM tablename2 LEFT JOIN tablename1 ON tablename2.columnname1 = tablename1.columnname2 WHERE tablename1.columnname1 = tablename2.columnname2 **Ejemplo**: SELECT Movies.name, Theatres.city from Theatres left join Movies on Theatres.ROWID = Movies.theatreID where Movies.distributionCity = theatre.city <br /> <table class="content-table"> <thead> <tr> <th>Name</th> <th>CIty</th> </tr> </thead> <tbody> <tr> <td>Dark Knight Rises</td> <td>Los Angeles</td> </tr> <tr> <td>Titanic</td> <td>New York</td> </tr> </tbody> </table> <br /> De manera similar, puedes comparar columnas pertenecientes a dos tablas diferentes al ejecutar las consultas UPDATE y DELETE. ### Subconsultas en la cláusula WHERE Una subconsulta es una consulta que se escribe dentro de otra sentencia de consulta. Catalyst te permite ejecutar subconsultas simples individuales con la cláusula WHERE. Puedes escribir subconsultas con la cláusula WHERE en las consultas SELECT, UPDATE y DELETE. La sintaxis de una subconsulta con la cláusula WHERE se muestra a continuación: SELECT column_name FROM table_name WHERE column_name operator (SELECT column_name FROM table_name) <br /> **Base de datos de ejemplo** Los detalles de empleados de Zylker Technologies se mantienen en el Data Store en la tabla *Zylker_Employee_DB*. La tabla contiene las siguientes columnas y filas: <table class="content-table"> <thead> <tr> <th class="w15p">ID</th> <th class="w30p">Name</th> <th class="w30p">Department</th> <th class="w25p">Salary</th> </tr> </thead> <tbody> <tr> <td>ZT-001</td> <td>Amelia Burrows</td> <td>Product Management</td> <td>15000</td> </tr> <tr> <td>ZT-2001</td> <td>Bruce Wayne</td> <td>Sr. Management</td> <td>85000</td> </tr> <tr> <td>ZT-239</td> <td>Clark Kane</td> <td>Media Relations</td> <td>85000</td> </tr> <tr> <td>ZT-4289</td> <td>Michelle Mascarenhas</td> <td>Finance</td> <td>89000</td> </tr> </tbody> </table> A continuación se muestra un ejemplo de sentencia de subconsulta para listar los salarios y los nombres de los empleados que ganan más que el empleado con el salario mínimo: SELECT Name, Salary FROM Zylker_Employee_DB WHERE Salary > (SELECT MIN (Salary) FROM Zylker_Employee_DB) <br /> <br /> <table class="content-table"> <thead> <tr> <th class="w50p">Zylker_Employee_DB.Salary</th> <th class="w50p">Zylker_Employee_DB.Name</th> </tr> </thead> <tbody> <tr> <td>15000</td> <td>Amelia Burrows</td> </tr> <tr> <td>85000</td> <td>Bruce Wayne</td> </tr> <tr> <td>89000</td> <td>Michelle Mascarenhas</td> </tr> </tbody> </table> Nota: * Esta funcionalidad solo está disponible en ZCQL V2. * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus organizaciones presentes en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser en el entorno de producción, si y cuando se habilite producción para el proyecto. <br /> -------------------------------------------------------------------------------- title: "Cláusula HAVING" description: "ZCQL es el lenguaje de consulta propio de Catalyst, modelado a partir de lenguajes de consulta familiares, que puedes usar para consultar la base de datos de tu aplicación de forma eficiente." last_updated: "2026-07-30T07:10:05.719Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/having/" service: "Cloud Scale" -------------------------------------------------------------------------------- # Cláusula HAVING ### Introducción La cláusula HAVING se usa para seleccionar registros de datos basándose en una condición especificada. También puedes aplicar funciones ZCQL en la consulta usando esta cláusula. La cláusula HAVING solo se puede usar con consultas SELECT. La sintaxis para usar la cláusula HAVING se muestra a continuación: SELECT column_name FROM base_table_name GROUP BY column_name HAVING column_name OPERATOR condition ### Operadores Admitidos por la Cláusula HAVING Puedes usar los siguientes operadores en las condiciones HAVING en consultas SELECT de ZCQL: <table class="content-table"> <thead> <tr> <th class="w25p">Operadores</th> <th class="w75p">Descripción</th> </tr> </thead> <tbody> <tr> <td>=</td> <td>Igual a</td> </tr> <tr> <td>IS</td> <td>TRUE si el operando es igual al valor</td> </tr> <tr> <td>IS NULL</td> <td>TRUE si el operando es un valor nulo</td> </tr> <tr> <td>IS NOT NULL</td> <td>TRUE si el operando no es un valor nulo</td> </tr> <tr> <td>=!</td> <td>No igual a</td> </tr> <tr> <td>LIKE</td> <td>TRUE si el operando coincide con un patrón</td> </tr> <tr> <td>NOT LIKE</td> <td>TRUE si el operando no coincide con un patrón</td> </tr> <tr> <td>BETWEEN</td> <td>TRUE si el valor del operando está entre los valores de inicio y fin</td> </tr> <tr> <td>IN</td> <td>TRUE si el operando es igual a una lista de expresiones</td> </tr> <tr> <td>NOT IN</td> <td>TRUE si el operando no es igual a una lista de expresiones</td> </tr> <tr> <td>&gt;</td> <td>Mayor que</td> </tr> <tr> <td>&gt;=</td> <td>Mayor o igual que</td> </tr> <tr> <td>&lt;</td> <td>Menor que</td> </tr> <tr> <td>&lt;=</td> <td>Menor o igual que</td> </tr> </tbody> </table> ### Funciones ZCQL con la Cláusula HAVING Las funciones ZCQL como SUM(), COUNT(), AVG(), etc., se pueden usar con la cláusula HAVING en una consulta SELECT. **Base de datos de ejemplo**: Los datos de empleados de Zylker Technologies se mantienen en el Data Store en la tabla *Zylker_Employee_DB*. La tabla contiene las siguientes columnas y filas: <table class="content-table"> <thead> <tr> <th class="w15p">ID</th> <th class="w30p">Name</th> <th class="w30p">Department</th> <th class="w25p">Salary</th> </tr> </thead> <tbody> <tr> <td>ZT-001</td> <td>Amelia Burrows</td> <td>Product Management</td> <td>15000</td> </tr> <tr> <td>ZT-2001</td> <td>Bruce Wayne</td> <td>Sr. Management</td> <td>85000</td> </tr> <tr> <td>ZT-239</td> <td>Clark Kane</td> <td>Media Relations</td> <td>85000</td> </tr> <tr> <td>ZT-4289</td> <td>Michelle Mascarenhas</td> <td>Finance</td> <td>89000</td> </tr> </tbody> </table> Usemos la función AVG() de ZCQL, con la cláusula HAVING en una consulta SELECT de ejemplo. <br /> SELECT Name, Department, Salary FROM Zylker_Employee_DB GROUP BY Department HAVING AVG(Salary) > 50000 <br /> <table class="content-table"> <thead> <tr> <th class="w30p">Zylker_Employee_DB.Salary</th> <th class="w35p">Zylker_Employee_DB.Department</th> <th class="w35p">Zylker_Employee_DB.Name</th> </tr> </thead> <tbody> <tr> <td>85000</td> <td>Sr. Management</td> <td>Bruce Wayne</td> </tr> <tr> <td>89000</td> <td>Finance</td> <td>Michelle Mascarenhas</td> </tr> </tbody> </table> Nota: * Esta funcionalidad solo está disponible en ZCQL V2. * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus Organizaciones presentes en el Entorno de Desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las Organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el Entorno de Desarrollo se mapearán automáticamente al ZCQL V2 Parser en el Entorno de Producción, si y cuando la producción esté habilitada para el proyecto. -------------------------------------------------------------------------------- title: "Cláusula JOIN" description: "ZCQL es el lenguaje de consulta propio de Catalyst, inspirado en lenguajes de consulta conocidos, que puedes utilizar para consultar la base de datos de tu aplicación de manera eficiente." last_updated: "2026-07-30T07:10:05.722Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/joins/" service: "Cloud Scale" -------------------------------------------------------------------------------- # Cláusula JOIN ### Introducción La cláusula JOIN se utiliza para combinar filas de dos o más tablas en una consulta SELECT, basándose en una columna relacionada entre ellas. Las filas de todas las tablas se generan juntas con la columna común fusionada. Antes de aprender más sobre la cláusula JOIN, comprendamos algunos términos clave relacionados con los joins: 1. Clave primaria: Una clave primaria es un identificador único de un registro en una tabla. Una tabla puede tener una columna como columna de clave primaria, y el valor de cada registro en esta columna debe ser único, es obligatorio y no puede duplicarse. 2. Clave foránea: Una columna de clave foránea en una tabla identifica de manera única una fila en otra tabla o en la misma tabla. La clave foránea de la segunda tabla hace referencia a la clave primaria de la primera tabla. 3. Tabla padre: En la cláusula JOIN, la tabla padre es la tabla base sobre la cual se realiza el join. 4. Tabla de unión: La tabla de unión es la tabla secundaria o la tabla hija que se fusiona con la tabla padre en la cláusula JOIN. Nota: Los joins entre dos tablas solo son posibles si existe una relación entre ellas. Una de las tablas debe hacer referencia a la columna de clave primaria de la otra tabla, por lo que la tabla de unión debe tener una columna de clave foránea de la tabla padre, o la tabla padre debe tener una columna de clave foránea de la tabla de unión. En nuestro ejemplo, la columna _MovieID_ es la clave primaria de la tabla _Movies_ ya que contiene el número de identificación único de una película. <br /> Base de datos de ejemplo: Creemos una tabla llamada "Theaters" en la aplicación de reserva de entradas que especifica las ubicaciones de todos los cines registrados en la aplicación. A continuación se muestran registros de ejemplo de la tabla Theaters: <table class="content-table"> <thead> <tr> <th><strong>TheaterID</strong></th> <th><strong>TheaterName</strong></th> <th><strong>Location</strong></th> </tr> </thead> <tbody> <tr> <td>047</td> <td>The Express Cinemas</td> <td>New York City</td> </tr> <tr> <td>048</td> <td>ANC Cinemas</td> <td>Rochester</td> </tr> <tr> <td>052</td> <td>Cosmos Theater</td> <td>Albany</td> </tr> <tr> <td>053</td> <td>FunTime Cinemas</td> <td>Buffalo</td> </tr> </tbody> </table> La columna _TheaterID_ es la clave primaria de la tabla _Theaters_ ya que contiene los números de identificación únicos de los cines. La columna _TheaterID_ en la tabla _Movies_ es la clave foránea de la columna _TheaterID_ en la tabla _Theaters_. Nota: Cuando usas una cláusula JOIN, debes especificar los nombres de las columnas y sus nombres de tabla para cada columna en la consulta como: '_table\_name.column\_name_''. Por ejemplo: '_Movies.MovieName_', '_Theaters.Location_' Si no especificas el nombre de la tabla junto con el nombre de la columna en una consulta, por defecto se considera que es una columna en la tabla base. <br /> ### Tipos de Joins Existen dos tipos de Joins que se pueden realizar en ZCQL. <br /> <br /> #### INNER JOIN El INNER JOIN devuelve los registros que tienen valores coincidentes tanto en la tabla padre como en la tabla de unión. Cuando usas un inner join en dos tablas, solo se producen como salida los registros cuyos valores coinciden para las columnas especificadas en ambas tablas.<br /> La sintaxis para usar un INNER JOIN es:<br /> SELECT column_name(s) FROM parent_table_name INNER JOIN join_table_name ON parent_table_name.column_name = join_table_name.column_name Ejemplo:<br /> Para ver una lista de los nombres de películas, fechas de proyección y horarios de la tabla _Movies_ junto con los nombres de los cines de la tabla _Theaters_, ejecuta la siguiente consulta: <br /> SELECT Movies.MovieName, Theatres.TheaterName, Movies.ShowDate, Movies.ShowTime, FROM Movies INNER JOIN Theatres ON Movies.TheaterID = Theatres.TheaterID Esto generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>MovieName</strong></th> <th><strong>TheaterName</strong></th> <th><strong>ShowDate</strong></th> <th><strong>ShowTime</strong></th> </tr> </thead> <tbody> <tr> <td>Ant-Man and the Wasp</td> <td>The Express Cinemas</td> <td>2018-07-13</td> <td>13:30:00</td> </tr> <tr> <td>Hotel Transylvania 3: Summer Vacation</td> <td>Cosmos Theater</td> <td>2018-07-13</td> <td>14:20:00</td> </tr> <tr> <td>The First Purge</td> <td>Cosmos Theater</td> <td>2018-07-14</td> <td>17:00:00</td> </tr> <tr> <td>The First Purge</td> <td>FunTime Cinemas</td> <td>2018-07-14</td> <td>21:30:00</td> </tr> </tbody> </table> <br /> #### LEFT JOIN El LEFT JOIN devuelve todos los registros de la tabla padre y los registros coincidentes de la tabla de unión. Cuando usas un left join en dos tablas, se devuelven todos los registros de la tabla padre, incluso si no tienen coincidencias en la tabla de unión. El resultado se muestra como 'NULL' para los registros que no tienen coincidencia en la tabla de unión. <br /> La sintaxis para usar un LEFT JOIN es:<br /> SELECT column_name(s) FROM parent_table_name LEFT JOIN join_table_name ON parent_table_name.column_name = join_table_name.column_name Ejemplo:<br /> Para ver una lista de cines y sus ubicaciones de la tabla _Theaters_ junto con las películas que se proyectan en los cines de la tabla _Movies_, ejecuta la siguiente consulta:<br /> SELECT Theaters.TheaterName, Theaters.Location, Movies.MovieName FROM Theaters LEFT JOIN Movies ON Theaters.TheaterID = Movies.TheaterID Esto generará la siguiente salida:<br /> <table class="content-table"> <thead> <tr> <th><strong>TheaterName</strong></th> <th><strong>Location</strong></th> <th><strong>MovieName</strong></th> </tr> </thead> <tbody> <tr> <td>The Express Cinemas</td> <td>New York City</td> <td>The First Purge</td> </tr> <tr> <td>ANC Cinemas</td> <td>Rochester</td> <td><strong>NULL</strong></td> </tr> <tr> <td>Cosmos Theater</td> <td>Albany</td> <td>Hotel Transylvania 3: Summer Vacation</td> </tr> <tr> <td>FunTime Cinemas</td> <td>Buffalo</td> <td>Skyscraper</td> </tr> </tbody> </table> Dado que no hay registros coincidentes para ANC Cinemas en la tabla Movies, el resultado se muestra como 'NULL'. <br /> <br /> ### Joins múltiples Puedes combinar un máximo de **cuatro** joins en una sola consulta ZCQL. Sin embargo, solo puedes escribir **una** condición JOIN para cada cláusula de join. Esto mostrará los resultados de cuatro tablas diferentes, donde una está vinculada a otra usando un INNER JOIN o un LEFT JOIN. Base de datos de ejemplo: Creemos una tabla llamada 'Pricing' en la aplicación de reserva de entradas que muestra el precio del boleto en dólares de una entrada individual para una película y un cine en particular. Esta tabla hace referencia a _TheaterID_ de la tabla _Theaters_ y _MovieID_ de la tabla _Movies_ como claves foráneas. A continuación se muestran registros de ejemplo de la tabla Pricing: <table class="content-table"> <thead> <tr> <th><strong>TheaterID</strong></th> <th><strong>MovieID</strong></th> <th><strong>Price</strong></th> </tr> </thead> <tbody> <tr> <td>047</td> <td>2056</td> <td>9.20</td> </tr> <tr> <td>048</td> <td>NULL</td> <td><strong>NULL</strong></td> </tr> <tr> <td>052</td> <td>2057</td> <td>8.64</td> </tr> <tr> <td>052</td> <td>2058</td> <td>11.50</td> </tr> <tr> <td>053</td> <td>2059</td> <td>7.44</td> </tr> </tbody> </table> Puedes ejecutar una consulta para mostrar el _TheaterName_ de la tabla _Theaters_, _MovieName_, _ShowDate_ y _ShowTime_ de la tabla _Movies_, y _Price_ de la tabla _Pricing_, ejecutando la siguiente consulta: SELECT Theaters.TheaterName,Movies.MovieName, Movies.ShowDate, Movies.ShowTime, Pricing.Price FROM Pricing LEFT JOIN Movies ON Theaters.TheaterID = Movies.TheaterID INNER JOIN Theaters ON Movies.MovieID = Pricing.MovieID Esto generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>TheaterName</strong></th> <th><strong>MovieName</strong></th> <th><strong>ShowDate</strong></th> <th><strong>ShowTime</strong></th> <th><strong>Price</strong></th> </tr> </thead> <tbody> <tr> <td>The Express Cinemas</td> <td>The First Purge</td> <td>2018-07-13</td> <td>13:00:00</td> <td>9.20</td> </tr> <tr> <td>ANC Cinemas</td> <td>NULL</td> <td>NULL</td> <td>NULL</td> <td>NULL</td> </tr> <tr> <td>Cosmos Theater</td> <td>Ant-Man and the Wasp</td> <td>2018-07-13</td> <td>14:20:00</td> <td>8.64</td> </tr> <tr> <td>Cosmos Theater</td> <td>Hotel Transylvania 3: Summer Vacation</td> <td>2018-07-14</td> <td>17:00:00</td> <td>11.50</td> </tr> <tr> <td>FunTime Cinemas</td> <td>Skyscraper</td> <td>2018-07-14</td> <td>21:30:00</td> <td>7.44</td> </tr> </tbody> </table> Nota: * Para utilizar todas las funcionalidades de la cláusula JOIN, te recomendamos migrar tu código base de ZCQL V1 a ZCQL V2. * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus organizaciones presentes en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser en el entorno de producción, si y cuando se habilite producción para el proyecto. * Puedes obtener más información sobre las mejoras y funcionalidades de ZCQL V2 en este documento de ayuda. -------------------------------------------------------------------------------- title: "GROUP BY y ORDER BY" description: "ZCQL es el lenguaje de consulta propio de Catalyst, modelado a partir de lenguajes de consulta familiares, que puedes usar para consultar la base de datos de tu aplicación de forma eficiente" last_updated: "2026-07-30T07:10:05.733Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/groupby-orderby/" service: "Cloud Scale" -------------------------------------------------------------------------------- ### Sentencia GROUP BY La sentencia GROUP BY se usa para agrupar los registros obtenidos en los resultados de una consulta de búsqueda por una o más columnas. GROUP BY permite que datos idénticos se agrupen juntos y se muestren secuencialmente. Cuando hay valores duplicados en una columna, la sentencia GROUP BY muestra los duplicados juntos. Los registros se ordenan luego según otras columnas. La sentencia GROUP BY está asociada con la sentencia SELECT y se usa frecuentemente con las funciones ZCQL. Se usa hacia el final de la consulta y por lo tanto debe satisfacer las sentencias JOIN y seguir las condiciones WHERE. La sintaxis básica para usar una sentencia GROUP BY junto con la sentencia SELECT es la siguiente: SELECT column_name(s) FROM parent_table_name GROUP BY column_name(s) <br /> Ejemplo: Para ver una lista de teatros y sus ubicaciones de la tabla _Theaters_, agrupados por la ubicación de los teatros, ejecuta la siguiente consulta: SELECT TheaterName, Location FROM Theaters GROUP BY Location <br /> Esto generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>TheaterName</strong></th> <th><strong>Location</strong></th> </tr> </thead> <tbody> <tr> <td>Cosmos Theater</td> <td>Albany</td> </tr> <tr> <td>FunTime Cinemas</td> <td>Buffalo</td> </tr> <tr> <td>The Express Cinemas</td> <td>New York City</td> </tr> <tr> <td>ANC Cinemas</td> <td>Rochester</td> </tr> </tbody> </table> #### Función BINARYOF() La función BINARYOF() solo se puede usar en una sentencia GROUP BY. La función se puede usar en lugares donde desees producir una salida que no sea sensible a mayúsculas y minúsculas y considere todos los valores en una columna de una tabla. La función BINARYOF() solo se puede usar en columnas con tipo de dato **VarChar** o **Text**. Por ejemplo, considera la siguiente tabla *Zylker_EMP*: <table class="content-table" style="width:30%"> <thead> <tr> <th>Names</th> </tr> </thead> <tbody> <tr> <td>AMELIA BURROWS</td> </tr> <tr> <td>amelia burrows</td> </tr> <tr> <td>amelia Burrows</td> </tr> <tr> <td>Amelia Burrows</td> </tr> </tbody> </table> A continuación se muestra una sentencia ZCQL de ejemplo para ilustrar la funcionalidad de BINARYOF() y su posible salida: SELECT Names FROM Zylker_EMP GROUP BY BINARYOF(Names)<br /> <table class="content-table" style="width:30%"> <thead> <tr> <th>Zylker_EMP.Names</th> </tr> </thead> <tbody> <tr> <td>AMELIA BURROWS</td> </tr> <tr> <td>amelia burrows</td> </tr> <tr> <td>amelia Burrows</td> </tr> <tr> <td>Amelia Burrows</td> </tr> </tbody> </table> Nota: * Esta funcionalidad solo está disponible en ZCQL V2. * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus Organizaciones presentes en el Entorno de Desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las Organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el Entorno de Desarrollo se mapearán automáticamente al ZCQL V2 Parser en el Entorno de Producción, si y cuando se habilite la producción para el proyecto. ### Sentencia ORDER BY La sentencia ORDER BY se usa para ordenar los registros obtenidos en los resultados de una consulta de búsqueda en orden ascendente o descendente, basándose en una o más columnas. Cuando la sentencia ORDER BY se usa para ordenar datos textuales, ordena los registros en orden alfabético. Similar a la sentencia GROUP BY, la sentencia ORDER BY está asociada con la sentencia SELECT y se usa frecuentemente después de la sentencia GROUP BY. Se usa hacia el final de la consulta, después de las sentencias de la cláusula JOIN o las condiciones WHERE, si están presentes, pero antes de la cláusula LIMIT. La sentencia ORDER BY debe entonces satisfacer las sentencias JOIN y seguir las condiciones WHERE. Nota: Si la sentencia ORDER BY sigue a una sentencia GROUP BY, la sentencia ORDER BY tiene precedencia y los resultados se ordenan primero según la sentencia ORDER BY, y luego se agrupan según la sentencia GROUP BY. * Si hay valores duplicados en una columna, la sentencia ORDER BY mostrará los duplicados juntos. Los registros se ordenan luego según otras columnas. * Las funciones ZCQL también se pueden usar con sentencias ORDER BY. Nota: Para utilizar todas las funcionalidades de la sentencia ORDER BY, te recomendamos migrar tu código de ZCQL V1 a ZCQL V2. Puedes obtener más información sobre las mejoras y funcionalidades de ZCQL V2 en este documento de ayuda La sintaxis básica para usar una sentencia ORDER BY con la sentencia SELECT es la siguiente: SELECT column_name(s) FROM parent_table_name ORDER BY column_name(s) [ASC | DESC] Nota:<br /> * Por defecto, la sentencia ORDER BY ordena los registros en orden ascendente sin usar la palabra clave 'ASC'. Para ordenar los registros en orden descendente, deberás usar la palabra clave 'DESC'. * En todas las columnas donde uses la cláusula ORDER BY, la funcionalidad de ASC y DESC ahora se puede aplicar. También puedes aplicar ASC y DESC para columnas individuales. <br /> Ejemplo: Para ver una lista de los precios de entradas de la tabla Pricing en orden descendente para cada película de la tabla _Movies_, ejecuta la siguiente consulta: SELECT Movies.MovieName, Pricing.Price FROM Movies INNER JOIN Pricing ON Movies.MovieID = Pricing.MovieID ORDER BY Pricing.Price DESC <br /> Esto generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>MovieName</strong></th> <th><strong>Price</strong></th> </tr> </thead> <tbody> <tr> <td>Hotel Transylvania 3: Summer Vacation</td> <td>11.50</td> </tr> <tr> <td>The First Purge</td> <td>9.20</td> </tr> <tr> <td>Ant-Man and the Wasp</td> <td>8.64</td> </tr> <tr> <td>Skyscraper</td> <td>7.44</td> </tr> </tbody> -------------------------------------------------------------------------------- title: "Cláusula LIMIT" description: "ZCQL es el lenguaje de consulta propio de Catalyst, modelado a partir de lenguajes de consulta familiares, que puedes usar para consultar la base de datos de tu aplicación de forma eficiente." last_updated: "2026-07-30T07:10:05.735Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/limit/" service: "Cloud Scale" -------------------------------------------------------------------------------- ### Cláusula LIMIT La cláusula LIMIT limita la cantidad de registros de datos que se muestran en el conjunto de resultados de una consulta de búsqueda. Contiene las siguientes propiedades: 1. OFFSET: OFFSET define el índice inicial del resultado, es decir, la posición del primer registro que se mostrará en el resultado. 2. VALUE: VALUE define la cantidad de registros a recuperar desde el índice inicial, es decir, el OFFSET. La cláusula LIMIT identifica el índice OFFSET y luego muestra la cantidad de registros según lo especificado en VALUE desde el índice OFFSET. También puedes especificar solo el valor sin especificar el offset, cuando el índice inicial es el primer registro. La cláusula LIMIT solo se usa cuando se necesita mostrar una cantidad específica de registros. Se usa hacia el final de la consulta después de todas las demás cláusulas y sentencias. La sintaxis básica para usar la cláusula LIMIT con una sentencia SELECT es: SELECT column_name(s) FROM parent_table_name LIMIT OFFSET, VALUE <br /> Ejemplo: Para ver una lista de películas de la tabla _Movies_ que conste de hasta tres registros desde el segundo índice inicial, ejecuta la siguiente consulta: SELECT * FROM Movies LIMIT 1,3 Generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>MovieID</strong></th> <th><strong>MovieName</strong></th> <th><strong>ShowDate</strong></th> <th><strong>ShowTime</strong></th> <th><strong>TheaterID</strong></th> </tr> </thead> <tbody> <tr> <td>2057</td> <td>Ant-Man and the Wasp</td> <td>2018-07-13</td> <td>14:20:00</td> <td>052</td> </tr> <tr> <td>2058</td> <td>Hotel Transylvania 3: Summer Vacation</td> <td>2018-07-14</td> <td>17:00:00</td> <td>052</td> </tr> <tr> <td>2059</td> <td>Skyscraper</td> <td>2018-07-14</td> <td>21:30:00</td> <td>053</td> </tr> </tbody> -------------------------------------------------------------------------------- title: "Funciones de ZCQL" description: "ZCQL es el lenguaje de consulta propio de Catalyst, inspirado en lenguajes de consulta conocidos, que puedes utilizar para consultar la base de datos de tu aplicación de manera eficiente." last_updated: "2026-07-30T07:10:05.735Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/zcql-functions/" service: "Cloud Scale" -------------------------------------------------------------------------------- # Funciones de ZCQL ZCQL admite algunas funciones matemáticas y analíticas integradas que te ayudan a realizar operaciones aritméticas rápidas sobre los datos y manipular el conjunto de resultados de una consulta de búsqueda para satisfacer tus necesidades. Estas funciones se utilizan en la sentencia SELECT para las columnas que se generan en la salida. ### MIN() <br /> La función MIN() devuelve el valor mínimo de la columna seleccionada. Puedes usarla para obtener el valor más pequeño de una columna que contiene datos numéricos o el registro que aparece primero en orden alfabético.<br /> La sintaxis básica para usar una función MIN() junto con la sentencia SELECT es:<br /> SELECT MIN(column_name) FROM base_table_name Ejemplo: Para ver la película menos costosa de la tabla _Pricing_, ejecuta la siguiente consulta:<br /> SELECT MIN(Price) FROM Pricing Esto generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>MIN(Price)</strong></th> </tr> </thead> <tbody> <tr> <td>7.44</td> </tr> </tbody> </table> <br /> ### MAX() La función MAX() devuelve el valor máximo de la columna seleccionada. Puedes usarla para obtener el valor más grande de una columna que contiene datos numéricos o el registro que aparece último en orden alfabético.<br /> La sintaxis básica para usar una función MAX() con la sentencia SELECT es:<br /> <br /> SELECT MAX(column_name) FROM base_table_name Ejemplo:<br /> Para ver la película más costosa de la tabla _Pricing_, ejecuta la siguiente consulta:<br /> SELECT MAX(Price) FROM Pricing Esto generará la siguiente salida:<br /> <table class="content-table"> <thead> <tr> <th><strong>MAX(Price)</strong></th> </tr> </thead> <tbody> <tr> <td>11.50</td> </tr> </tbody> </table> <br /> ### COUNT() La función COUNT() devuelve el número de filas en los registros que se obtienen para una columna particular en la salida. La función COUNT también se usa con la sentencia SELECT. La sintaxis básica para usar una función COUNT() con la sentencia SELECT es: SELECT COUNT(column_name) FROM base_table_name **Ejemplo:** Para ver el número de cines en New York City y Albany de la tabla _Theaters_, ejecuta la siguiente consulta:<br /> SELECT COUNT(TheaterName) FROM Theaters WHERE Location='New York City' OR Location='Albany' Esto generará la siguiente salida:<br /> <table class="content-table"> <thead> <tr> <th><strong>COUNT(TheaterName)</strong></th> </tr> </thead> <tbody> <tr> <td>2</td> </tr> </tbody> </table> <br /> ### SUM() La función SUM() calcula y devuelve la suma total de los registros de una columna numérica. Solo se puede usar para una columna que contiene datos numéricos. La función SUM() también se puede usar con la sentencia SELECT para una columna individual.<br /> La sintaxis básica para usar una función SUM() con la sentencia SELECT es:<br /> SELECT SUM(column_name) FROM base_table_name Ejemplo:<br /> Para ver la suma total de los cargos de entradas para 'The First Purge' y 'Hotel Transylvania 3: Summer Vacation' de la tabla _Pricing_, ejecuta la siguiente consulta:<br /> SELECT SUM(Price) FROM Pricing WHERE MovieID='2056' OR MovieID='2058' Esto generará la siguiente salida:<br /> <table class="content-table"> <thead> <tr> <th><strong>SUM(Price)</strong></th> </tr> </thead> <tbody> <tr> <td>20.7</td> </tr> </tbody> </table> <br /> ### AVG() La función AVG() calcula y devuelve el valor promedio de los registros de una columna numérica. Solo se puede usar para una columna que contiene datos numéricos. La función AVG() se utiliza junto con la sentencia SELECT para una columna particular únicamente. La función AVG () de ZCQL se puede aplicar a los siguientes tipos de datos: - **Date** - **DateTime** - **Boolean** Nota: * Esta funcionalidad solo está disponible en ZCQL V2. * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus organizaciones presentes en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser en el entorno de producción, si y cuando se habilite producción para el proyecto. La sintaxis básica para usar una función AVG() con la sentencia SELECT es:<br /> SELECT AVG(column_name) FROM base_table_name Ejemplo:<br /> Para ver el precio promedio del boleto para las películas en la tabla _Pricing_, ejecuta la siguiente consulta:<br /> SELECT AVG(Price) As AverageTicketPrice FROM Pricing Esto generará la siguiente salida: <table class="content-table"> <thead> <tr> <th><strong>AVG(Price)</strong></th> </tr> </thead> <tbody> <tr> <td>9.19</td> </tr> </tbody> </table> <br /> ### DISTINCT La sentencia DISTINCT devuelve solo los valores de registros distintos para una columna. Si hay valores duplicados en una columna, esta sentencia no devolverá los duplicados. La sentencia DISTINCT se utiliza junto con la sentencia SELECT en una consulta. La sintaxis básica para usar una sentencia SELECT DISTINCT es:<br /> SELECT DISTINCT column_name(s) FROM base_table_name Ejemplo:<br /> Para ver los cines distintos donde se proyectan las películas, ejecuta la siguiente consulta:<br /> SELECT DISTINCT Theaters.TheaterName FROM Movies INNER JOIN Theaters ON Movies.TheaterID=Theaters.TheaterID Esto generará la siguiente salida:<br /> <table class="content-table"> <thead> <tr> <th><strong>TheaterName</strong></th> </tr> </thead> <tbody> <tr> <td>The Express Cinemas</td> </tr> <tr> <td>Cosmos Theater</td> </tr> <tr> <td>FunTime Cinemas</td> </tr> </tbody> </table> ### Usar múltiples funciones de ZCQL Puedes usar múltiples funciones de ZCQL en la misma columna en una sola sentencia de consulta ZCQL. **Base de datos de ejemplo**: Los detalles de empleados de Zylker Technologies se mantienen en el Data Store en la tabla *Zylker_Employee_DB*. La tabla contiene las siguientes columnas y filas: <table class="content-table"> <thead> <tr> <th class="w15p">ID</th> <th class="w30p">Name</th> <th class="w30p">Department</th> <th class="w25p">Salary</th> </tr> </thead> <tbody> <tr> <td>ZT-001</td> <td>Amelia Burrows</td> <td>Product Management</td> <td>15000</td> </tr> <tr> <td>ZT-2001</td> <td>Bruce Wayne</td> <td>Sr. Management</td> <td>85000</td> </tr> <tr> <td>ZT-239</td> <td>Clark Kane</td> <td>Media Relations</td> <td>4500</td> </tr> <tr> <td>ZT-4289</td> <td>Michelle Mascarenhas</td> <td>Finance</td> <td>89000</td> </tr> </tbody> </table> A continuación, aplicamos múltiples funciones de ZCQL juntas en la consulta, como se muestra a continuación: SELECT MIN (Salary), MAX (Salary), COUNT (Salary), SUM (Salary), AVG (Salary) FROM Zylker_Employee_DB <table class="content-table"> <thead> <tr> <th class="w20p">MAX(Salary)</th> <th class="w20p">SUM(Salary)</th> <th class="w20p">MIN(Salary)</th> <th class="w20p">AVG(Salary)</th> <th class="w20p">COUNT(Salary)</th> </tr> </thead> <tbody> <tr> <td>89000</td> <td>193500</td> <td>4500</td> <td>48975</td> <td>4</td> </tr> </tbody> </table> Nota: * Esta funcionalidad solo está disponible en ZCQL V2. * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus organizaciones presentes en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser en el entorno de producción, si y cuando se habilite producción para el proyecto. -------------------------------------------------------------------------------- title: "Sintaxis y excepciones de ZCQL V2" description: "ZCQL es el lenguaje de consulta propio de Catalyst, inspirado en lenguajes de consulta conocidos, que puedes utilizar para consultar la base de datos de tu aplicación de manera eficiente." last_updated: "2026-07-30T07:10:05.736Z" source: "https://docs.catalyst.zoho.com/es/cloud-scale/help/zcql/syntax-exceptions/" service: "Cloud Scale" -------------------------------------------------------------------------------- # Sintaxis y excepciones de ZCQL V2 Catalyst ha añadido varias mejoras y actualizaciones de sintaxis para ayudarte a escribir consultas ZCQL de manera más efectiva. Estas nuevas actualizaciones de sintaxis proporcionarán funcionalidades adicionales y te permitirán realizar operaciones relacionadas con datos en el Data Store con mucha mayor facilidad. Nota:<br /> * Para usar estas mejoras de funcionalidad, necesitarás migrar a la versión V2. Las actualizaciones de sintaxis no serán aplicables si las implementas mientras ejecutas comandos ZCQL en V1. * A partir del 1 de diciembre de 2024, todos tus proyectos actuales en todas tus organizaciones presentes en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser. * A partir del 1 de abril de 2025, todos los proyectos presentes en todas las organizaciones que ya hayan sido mapeados al ZCQL V2 Parser en el entorno de desarrollo se mapearán automáticamente al ZCQL V2 Parser en el entorno de producción, si y cuando se habilite producción para el proyecto. Las siguientes excepciones y particularidades de sintaxis deben tenerse en cuenta al ejecutar una consulta ZCQL: 1. La función ZCQL AVG () se puede aplicar a los siguientes tipos de datos: - **Date** - **DateTime** - **Boolean** 2. Cuando indicas un valor en tu sentencia ZCQL, indica el valor entre comillas simples.<br /> Por ejemplo, si necesitas obtener un nombre particular de una base de datos de empleados, escribirás el comando de la siguiente manera: SELECT Name FROM Employee_DB WHERE name = 'Amelia' 3. Si una columna es de tipo de dato Boolean: - No se permiten valores de cadena. - El tipo de dato Boolean solo admitirá los siguientes valores: - FALSE - TRUE - NULL 4. Si estás usando un **tipo de dato Encrypted**, las siguientes funciones de ZCQL no se pueden usar en esa columna: - AVG() - SUM() - MAX() - MIN() 5. Se han añadido excepciones apropiadas cuando usas operadores comparativos como Less Than, Greater Than, Less Than or Equal y Greater Than or Equal en tipos de datos Encrypted Text y Boolean. Estas excepciones no son aplicables para los operadores Equal y Not Equal. 6. Las subconsultas ahora son compatibles en las sentencias de la cláusula WHERE. Puedes obtener más información sobre ellas en este documento de ayuda. 7. La cláusula ORDER BY ahora admite el uso de funciones de ZCQL. 8. En todas las columnas donde uses la cláusula ORDER BY, ahora se puede aplicar la funcionalidad ASC y DESC. También puedes aplicar ASC y DESC para columnas individuales. **Base de datos de ejemplo**:<br /> Considera la siguiente base de datos - **ZylkerEmployeeCompensation** <table class="content-table"> <thead> <tr> <th class="w50p">Name</th> <th class="w25p">Salary</th> <th class="w25p">Reimbursement</th> </tr> </thead> <tbody> <tr> <td>Michelle Mascarenhas</td> <td>90000</td> <td>10000</td> </tr> <tr> <td>Bruce Kyle</td> <td>3000000</td> <td>45000</td> </tr> <tr> <td>Clark Kane</td> <td>3300</td> <td>1500</td> </tr> <tr> <td>Judith Bridges</td> <td>4700</td> <td>300</td> </tr> <tr> <td>Devon Dreymond</td> <td>80000</td> <td>2300</td> </tr> <tr> <td>Ashley Kim</td> <td>6000</td> <td>200</td> </tr> </tbody> </table> Ejecuta el siguiente comando para listar la tabla SELECT Salary, Reimbursement FROM ZylkerEmployeeCompensation ORDER BY Salary ASC, Reimbursement DESC **Salida:** <br /> <table class="content-table"> <thead> <tr> <th class="w50p">ZylkerEmployeeCompensation.Salary</th> <th class="w50p">ZylkerEmployeeCompensation.Reimbursement</th> </tr> </thead> <tbody> <tr> <td>3300</td> <td>45000</td> </tr> <tr> <td>4700</td> <td>10000</td> </tr> <tr> <td>6000</td> <td>2300</td> </tr> <tr> <td>80000</td> <td>1500</td> </tr> <tr> <td>90000</td> <td>300</td> </tr> <tr> <td>3000000</td> <td>200</td> </tr> </tbody> </table> 9. Se activarán excepciones apropiadas en los siguientes casos: - Si se ha excedido el valor máximo/mínimo permitido en el tipo de dato **Integer**. - Si la longitud de caracteres es mayor que el valor establecido por ti en el tipo de dato **VarChar**. - Si el valor está fuera del rango soportado en el tipo de dato **BIGINT**. 10. Puedes escribir **cuatro** cláusulas JOIN en una sola sentencia ZCQL. Sin embargo, solo puedes escribir **una** condición JOIN para cada cláusula de join. 11. La funcionalidad de **alias de tabla** ahora es compatible en ZCQL. Ahora puedes invocar la funcionalidad de alias en ZCQL usando el comando AS de ZCQL. Con este comando puedes referirte a tu tabla con otros nombres. **Base de datos de ejemplo**:<br /> Considera las siguientes bases de datos: **Tabla 1: ZylkerEmployeeCompensation** <table class="content-table"> <thead> <tr> <th class="w50p">Name</th> <th class="w25p">Salary</th> <th class="w25p">Reimbursement</th> </tr> </thead> <tbody> <tr> <td>Michelle Mascarenhas</td> <td>90000</td> <td>10000</td> </tr> <tr> <td>Bruce Kyle</td> <td>3000000</td> <td>45000</td> </tr> <tr> <td>Clark Kane</td> <td>3300</td> <td>1500</td> </tr> <tr> <td>Judith Bridges</td> <td>4700</td> <td>300</td> </tr> <tr> <td>Devon Dreymond</td> <td>80000</td> <td>2300</td> </tr> <tr> <td>Ashley Kim</td> <td>6000</td> <td>200</td> </tr> </tbody> </table> **Tabla 2: ZylkerEmployeeRelation** <table class="content-table"> <thead> <tr> <th class="w50p">Manager</th> <th class="w50p">Member</th> </tr> </thead> <tbody> <tr> <td>Michelle Mascarenhas</td> <td>Bruce Kyle</td> </tr> <tr> <td>Michelle Mascarenhas</td> <td>Clark Kane</td> </tr> <tr> <td>Judith Bridges</td> <td>Michelle Mascarenhas</td> </tr> </tbody> </table> Ejecuta el siguiente comando para listar la tabla SELECT Managers.Name, Members.Name FROM ZylkerEmployeeCompensation AS Managers INNER JOIN ZylkerEmployeeRelation AS asso ON Managers.ROWID = asso.Manager INNER JOIN ZylkerEmployeeCompensation AS Members ON Members.ROWID = asso.Member **Salida:** <br/> <table class="content-table"> <thead> <tr> <th class="w50p">Manager.Name</th> <th class="w50p">Member.Name</th> </tr> </thead> <tbody> <tr> <td>Michelle Mascarenhas</td> <td>Bruce Kyle</td> </tr> <tr> <td>Michelle Mascarenhas</td> <td>Clark Kane</td> </tr> <tr> <td>Judith Bridges</td> <td>Michelle Mascarenhas</td> </tr> </tbody> </table> Nota: La operación de alias de tabla solo es compatible con sentencias **SELECT**. 12. Puedes verificar si tienes un valor NULL usando el operador **IS/IS NOT**. La compatibilidad del operador **IS/IS NOT** solo está disponible para valores NULL. 13. Al escribir sentencias GROUP BY con Binaryof(), se deben recordar las siguientes reglas de ZCQL: - La funcionalidad Binaryof() solo se puede usar en sentencias GROUP BY. - Binaryof() solo se puede usar en columnas con tipo de dato VarChar o Text. - Cuando se usa Binaryof() en una sentencia GROUP BY, los valores devueltos distinguen entre mayúsculas y minúsculas. Por ejemplo, considera que tienes los valores 'AMELIA', 'amelia', 'Burrows' y 'burrows' en una columna llamada Name, en una tabla llamada Zylker_EMP. Si usas el siguiente comando:<br /> Select Name from Zylker_EMP group by binaryof(Name) El resultado podría ser cualquiera de los siguientes:<br /> - AMELIA - amelia - burrows - Burrows 14. Los nombres de columnas ahora pueden contener valores numéricos. Puedes indicar dichos nombres de columna en la consulta usando la puntuación de acento grave (**`**). Por ejemplo, una consulta SELECT en una tabla llamada Numbers con una columna llamada 01 se puede escribir de la siguiente manera: SELECT `01` FROM Numbers<br /> ### Lista de excepciones de ZCQL La siguiente es una lista de excepciones comunes y sentencias de consulta de ejemplo que pueden activar estas excepciones. Asegúrate de revisar la lista y seguir estrictamente la sintaxis de ZCQL para evitar activar estas excepciones. <table class="content-table"> <thead> <tr> <th class="w15p">Tipo de dato</th> <th class="w20p">Caso</th> <th class="w25p">Consulta ZCQL de ejemplo</th> <th class="w40p">Excepción activada</th> </tr> </thead> <tbody> <tr> <td rowspan="5"><strong>Encrypted Text</strong></td> <td>Ciertos operadores no son compatibles</td> <td>SELECT * FROM temp WHERE enc > 'temsp'</td> <td>Operator > is not supported for<br />ENCRYPTED TEXT La misma excepción se aplica, pero el mensaje de excepción se modificará en consecuencia si usas estos operadores **<**, **<=**, **>=** en la sentencia ZCQL</td> </tr> <tr> <td>LIKE no es compatible</td> <td>SELECT * FROM temp WHERE enc LIKE '*temsp'</td> <td>Operator LIKE is not supported for<br />ENCRYPTED TEXT La misma excepción se aplica, pero el mensaje de excepción se modificará en consecuencia si usas **NOT LIKE** en la sentencia ZCQL</td> </tr> <tr> <td>BETWEEN no es compatible</td> <td>SELECT * FROM temp WHERE enc BETWEEN 'one' AND 'ten'</td> <td>Operator BETWEEN is not supported for<br />ENCRYPTED TEXT La misma excepción se aplica, pero el mensaje de excepción se modificará en consecuencia si usas **NOT BETWEEN** en la sentencia ZCQL</td> </tr> <tr> <td>IN no es compatible</td> <td>SELECT * FROM temp WHERE enc IN ('one','three')</td> <td>Operator IN is not supported for<br />ENCRYPTED TEXT La misma excepción se aplica si usas **NOT IN** en tu consulta, pero el mensaje de excepción se modificará en consecuencia</td> </tr> <tr> <td>Las funciones de ZCQL no son compatibles</td> <td>SELECT AVG(enc) FROM temp</td> <td>AVG() function is not supported for<br />ENCRYPTED_TEXT Las funciones de ZCQL no son compatibles con **Encrypted Text**.</td> </tr> <tr> <td rowspan="4"><strong>Boolean</strong></td> <td>Ciertos operadores no son compatibles</td> <td>SELECT * FROM temp WHERE bools > FALSE</td> <td>Operator > is not supported for BOOLEAN La misma excepción se aplica, pero el mensaje de excepción se modificará en consecuencia si usas estos operadores **<**, **<=**, **>=** en la sentencia ZCQL</td> </tr> <tr> <td>LIKE no es compatible</td> <td>SELECT * FROM temp WHERE bools LIKE FALSE</td> <td>Operator LIKE is not supported for BOOLEAN La misma excepción se aplica si usas **NOT LIKE** en tu consulta, pero el mensaje de excepción se modificará en consecuencia</td> </tr> <tr> <td>BETWEEN no es compatible</td> <td>SELECT * FROM temp WHERE bools BETWEEN TRUE and FALSE</td> <td>Operator BETWEEN is not supported for<br />BOOLEAN La misma excepción se aplica si usas **NOT BETWEEN** en tu consulta, pero el mensaje de excepción se modificará en consecuencia</td> </tr> <tr> <td>IN no es compatible</td> <td>SELECT * FROM temp WHERE bools IN (TRUE, FALSE)</td> <td>Operator IN is not supported for BOOLEAN La misma excepción se aplica si usas **NOT IN** en tu consulta, pero el mensaje de excepción se modificará en consecuencia</td> </tr> <tr> <td rowspan="1"><strong>VarChar</strong></td> <td>Longitud máxima excedida</td> <td>INSERT INTO temp (Fishes) value ('salmon')</td> <td>'salmon' data too long for column 'Fishes' La columna Fishes fue creada como **VarChar** y el **MaxLength** se estableció en 5. En esta sentencia, 'Salmon' excede el **MaxLength**</td> </tr> <tr> <td rowspan="1"><strong>Integer</strong></td> <td>Valor máximo excedido</td> <td>INSERT INTO temp (numbers) VALUE (546895326908)</td> <td>For column 'ints' INT value should be between<br />-9999999999 and 9999999999 La columna numbers fue creada como **INT**. El valor del tipo de dato **INT** debe estar entre -9999999999 y 9999999999</td> </tr> <tr> <td rowspan="1"><strong>Big Integer</strong></td> <td>Valor máximo excedido</td> <td>INSERT INTO temp (numbers) VALUE (92343432412351<br />435123453245)</td> <td>Given numeric value 92343432412351<br />435123453 is too large La columna numbers fue creada como **BIGINT**. El valor del tipo de dato **BIGINT** debe estar entre -9223372036854775808 y 9223372036854775807</td> </tr> <tr> <td rowspan="1"><strong>Text</strong></td> <td>Valor no encerrado entre comillas simples</td> <td>SELECT * FROM temp WHERE name = one</td> <td>Unknown Table temp or Unknown Column<br />one in WHERE El valor one se considerará como columna si no está encerrado entre comillas: 'one'</td> </tr> </tbody> </table> --- ## API Reference — ZCQL -------------------------------------------------------------------------------- title: "Ejecutar consulta ZCQL" description: "Esta API te permite ejecutar una consulta ZCQL para obtener, insertar, actualizar o eliminar datos de las tablas en el Data Store." last_updated: "2026-07-30T07:10:05.742Z" source: "https://docs.catalyst.zoho.com/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/" service: "Cloud Scale" -------------------------------------------------------------------------------- # ZCQL ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de obtención, inserción, actualización y eliminación de datos en las tablas del Catalyst Data Store. Puedes ejecutar una variedad de consultas DML usando ZCQL para obtener o manipular datos, y usar varias cláusulas y sentencias como las cláusulas SQL Join, sentencias Groupby y OrderBy, y funciones SQL integradas. # Ejecutar una consulta ZCQL ### Descripción Esta API te permite ejecutar una consulta ZCQL para obtener, insertar, actualizar o eliminar datos de las tablas en el Data Store. Puedes ejecutar esta API pasando una consulta ZCQL en la solicitud JSON, como se muestra en las solicitudes de ejemplo. Nota: El formato de solicitud de la API es el mismo para todas las operaciones de ejecución de consultas ZCQL. ### Detalles de la solicitud #### URL de solicitud <p>{api-domain}/baas/v1/project/{project_id}/query</p> El dominio específico del DC para acceder a Catalyst API El ID único del proyecto #### Encabezados de solicitud **Authorization:** Zoho-oauthtoken {oauth_token} <br> **Content-Type:** application/json **Encabezados opcionales** <br> **CATALYST-ORG:** {org_id} **Environment:** Development #### Scope ZohoCatalyst.zcql.CREATE Nota: Esta operación también puede ejecutarse con permisos de autenticación de usuario de Catalyst usando los SDKs de Catalyst. Consulta la [sección de Prerrequisitos de la API de Catalyst](/es/api/introduction/overview-and-prerequisites/#prerequisites) para más detalles. #### Propiedades JSON de la solicitud La consulta ZCQL a ejecutar ### Detalles de la respuesta Operaciones de obtención de datos: La API devuelve los registros que se obtuvieron como resultado de la ejecución de la consulta como respuesta. Operaciones de inserción y actualización de datos: La API devuelve los registros que fueron insertados o actualizados a través de la consulta como respuesta. Operaciones de eliminación de datos: La API devuelve la cantidad de filas eliminadas. curl -X POST \ https://api.catalyst.zoho.com/baas/v1/project/4000000006007/query \ -H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57" \ -H "Content-Type: application/json" \ -d '{ "query":"SELECT EmpID, EmpName, Department, Address from EmpDetails ORDER BY EmpID ASC LIMIT 1000,5" }' { "status": "success", "data": [ { "EmpDetails": { "CREATORID": "3376000000002003", "MODIFIEDTIME": "2023-06-05 15:09:33:881", "CREATEDTIME": "2023-06-05 15:09:33:881", "ROWID": "3376000001924975", "EmpID": "1001", "EmpName": "Allison Powell", "Department":"Marketing", "Address": "13, Winter Avenue, Philadelphia, PY" } }, { "EmpDetails": { "CREATORID": "3376000000002003", "MODIFIEDTIME": "2023-06-05 15:09:33:881", "CREATEDTIME": "2023-06-05 15:09:33:881", "ROWID": "3376000001927682", "EmpID": "1002", "EmpName": "James Cortez", "Department":"HR", "Address": "25, Blossom Street, Austin, TX" } }, { "EmpDetails": { "CREATORID": "3376000000002003", "MODIFIEDTIME": "2023-06-02 21:04:11:111", "CREATEDTIME": "2023-06-02 15:05:21:001", "ROWID": "3376000001224112", "EmpID": "1003", "EmpName": "Han Chan", "Department":"Sales", "Address": "112, St.Patrick's Road, Louisville, KY" } }, { "EmpDetails": { "CREATORID": "337600000003111", "MODIFIEDTIME": "2023-06-02 21:04:11:111", "CREATEDTIME": "2023-06-02 15:05:21:001", "ROWID": "3376000001242012", "EmpID": "1004", "EmpName": "Rubella Miguel", "Department":"Accounts", "Address": "333, Marine Bay, Salt Lake City, UT" } }, { "EmpDetails": { "CREATORID": "3376000000115254", "MODIFIEDTIME": "2023-04-12 21:04:10:521", "CREATEDTIME": "2023-06-11 15:05:02:541", "ROWID": "3376000001241341", "EmpID": "1005", "EmpName": "Ronwick Boseman", "Department":"Support", "Address": "61, Gringott's Avenue, Herfordshire, CO" } } ] } curl -X POST \ https://api.catalyst.zoho.com/baas/v1/project/4000000006007/query \ -H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57 \ -H "Content-Type: application/json" \ -d '{ "query":"INSERT INTO EmpDetails VALUES (1007,'Randy Marsh','Sales','42, Tenth Street, Jacksonville, FL', '14 MAR 2017')" }' { "status": "success", "data": [ { "EmpDetails": { "CREATORID": "3813000000002003", "EmpID": "1007", "EmpName": "Randy Marsh", "Department":"Sales", "Address": "42, Tenth Street, Jacksonville, FL", "DOJ": "14 MAR 2017", "MODIFIEDTIME": "2021-08-04 09:10:14:752", "CREATEDTIME": "2021-08-04 09:10:14:752", "ROWID": "3813000000214001" } } ] } curl -X POST \ https://api.catalyst.zoho.com/baas/v1/project/4000000006007/query \ -H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57 \ -H "Content-Type: application/json" \ -d '{ "query":"UPDATE EmpDetails SET Department='Operations' WHERE EmpID=1007" }' { "status": "success", "data": [ { "EmpDetails": { "CREATORID": "3813000000002003", "EmpID": "1007", "EmpName": "Randy Marsh", "Department":"Operations", "Address": "42, Tenth Street, Jacksonville, FL", "DOJ": "14 MAR 2017", "MODIFIEDTIME": "2021-08-04 09:11:54:318", "CREATEDTIME": "2021-08-04 09:10:14:752", "ROWID": "3813000000214001" } } ] } curl -X POST \ https://api.catalyst.zoho.com/baas/v1/project/4000000006007/query \ -H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57 \ -H "Content-Type: application/json" \ -d '{ "query":"DELETE FROM EmpDetails WHERE EmpID=1007" }' { "status": "success", "data": [ { "EmpDetails": { "DELETED_ROWS_COUNT": 1 } } ] } Execute ZCQL Query- Java SDK</br></br> Execute ZCQL Query- Node.js SDK</br></br> Execute ZCQL Query- Python SDK</br></br> Execute ZCQL Query- Web SDK --- ## SDK — Android — ZCQL -------------------------------------------------------------------------------- title: "Ejecutar consulta ZCQL" description: "ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de creación, recuperación y modificación de datos en Data Store." last_updated: "2026-07-30T07:10:05.747Z" source: "https://docs.catalyst.zoho.com/es/sdk/android/v2/cloud-scale/zcql/execute-zcql-query/" service: "Cloud Scale" related: - Data Store (/es/cloud-scale/help/data-store/introduction) - ZCQL (/es/cloud-scale/help/zcql/introduction/) - Execute ZCQL - API (/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/#ExecuteZCQLQuery) -------------------------------------------------------------------------------- # ZCQL ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de creación, recuperación y modificación de datos en Data Store. Admite consultas con funciones integradas, cláusulas SQL Join y otras sentencias y condiciones. ### Ejecutar una consulta ZCQL Antes de ejecutar una consulta ZCQL para obtener el conjunto de datos requerido, debes construir la consulta para pasarla al método **execute()**. Puedes aprender sobre la sintaxis de ZCQL en la página de ayuda de ZCQL. Debes pasar una instancia de **ZCatalystSelectQuery** al método execute(), como se muestra en la sintaxis de código de una ejecución de consulta ZCQL a continuación. El &lt;DATA_STORE_INSTANCE&gt; utilizado aquí es la instancia definida en la página de instancia de Data Store. ZCatalystApp.getInstance().getDataStoreInstance().execute( selectQuery: ZCatalystSelectQuery, success: (List&lt;Map&lt;String, Map&lt;String, Any?&gt;&gt;&gt;) → Unit, failure: ((ZCatalystException) → Unit)? ): ZCatalystRequest&lt;ZCatalystResponse&lt;List&lt;Map&lt;String, Any?&gt;&gt;&gt;&gt;&gt;? **Parámetros**: * **selectQuery**: La instancia del tipo ZCatalystSelectQuery que se pasará Puedes crear una instancia selectQuery para ZCatalystSelectQuery para las sentencias soportadas por ZCQL, de la siguiente manera: ZCatalystSelectQuery.Builder() .select(columns: Set&lt;Column&gt;): ZCatalystSelectQuery.Builder .selectAll(): ZCatalystSelectQuery.Builder .where(column: String, comparator: ZCatalystUtil.Comparator, value: String): ZCatalystSelectQuery.Builder .from(tableName: String): ZCatalystSelectQuery.Builder .and(column: String, comparator: ZCatalystUtil.Comparator, value: String): ZCatalystSelectQuery.Builder .groupBy(columns: Set&lt;Column&gt;): ZCatalystSelectQuery.Builder .orderBy(columns: Set&lt;Column&gt;, sortOrder: ZCatalystUtil.SortOrder): ZCatalystSelectQuery.Builder .innerJoin(tableName: String): ZCatalystSelectQuery.Builder .leftJoin(tableName: String): ZCatalystSelectQuery.Builder .on(joinColumn1: String, comparator: ZCatalystUtil.Comparator, joinColumn2: String): ZCatalystSelectQuery.Builder .or(column: String, comparator: ZCatalystUtil.Comparator, value: String): ZCatalystSelectQuery.Builder .limit(offset: Int, value: Int?): ZCatalystSelectQuery.Builder .build(): ZCatalystSelectQuery A continuación se muestra un fragmento de código de ejemplo de una ejecución de consulta ZCQL: val query = ZCatalystSelectQuery.Builder() .selectAll() .from("EmployeeDetails") //Reemplaza esto con el nombre de tu tabla .where("Location", ZCatalystUtil.Comparator.EQUAL_TO, "Austin") .and("Department", ZCatalystUtil.Comparator.EQUAL_TO, "Marketing") .or("isActive", ZCatalystUtil.Comparator.EQUAL_TO, "true") .limit(5) .build() ZCatalystApp.getInstance().getDataStoreInstance().execute(query, { println("Query executed successfully. $it") }, { exception -> println("Exception occured $exception") }) --- ## SDK — Flutter — ZCQL -------------------------------------------------------------------------------- title: "Ejecutar consulta ZCQL" description: "ZCQL es el lenguaje de consultas propio de Catalyst que te permite realizar operaciones de creación, recuperación y modificación de datos en Data Store." last_updated: "2026-07-30T07:10:05.748Z" source: "https://docs.catalyst.zoho.com/es/sdk/flutter/v2/cloud-scale/zcql/execute-zcql-query/" service: "Cloud Scale" related: - Data Store (/es/cloud-scale/help/data-store/introduction) - ZCQL (/es/cloud-scale/help/zcql/introduction/) - Execute ZCQL - API (/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/#ExecuteZCQLQuery) -------------------------------------------------------------------------------- # ZCQL ZCQL es el lenguaje de consultas propio de Catalyst que te permite realizar operaciones de creación, recuperación y modificación de datos en Data Store. Admite consultas con funciones integradas, cláusulas SQL Join y otras sentencias y condiciones. ### Ejecutar una consulta ZCQL Flutter te permite realizar operaciones de recuperación de datos usando ZCQL. Antes de ejecutar una consulta ZCQL para obtener el conjunto de datos requerido, debes construir la consulta para pasarla al método **getData()**. Puedes aprender sobre la sintaxis de ZCQL en la página de ayuda de ZCQL. Debes pasar una instancia de **ZCatalystSelectQuery** al método getData(), como se muestra en la sintaxis de código de una ejecución de consulta ZCQL a continuación. El &lt;DATA_STORE_INSTANCE&gt; utilizado aquí es la instancia definida en la página de instancia de Data Store. Future<(APIResponse, List&lt;dynamic&gt;?)> ZCatalystApp.getInstance().getDataStoreInstance().getData( ZCatalystSelectQuery selectQuery) **Parámetros**: * **selectQuery**: La instancia del tipo ZCatalystSelectQuery que se pasará Puedes crear una instancia selectQuery para ZCatalystSelectQuery para las sentencias admitidas por ZCQL, de la siguiente manera: ZCatalystSelectQuery.Builder() .select(columns: Set&lt;Column&gt;): ZCatalystSelectQuery.Builder .selectAll(): ZCatalystSelectQuery.Builder .where(column: String, comparator: ZCatalystUtil.Comparator, value: String): ZCatalystSelectQuery.Builder .from(tableName: String): ZCatalystSelectQuery.Builder .and(column: String, comparator: ZCatalystUtil.Comparator, value: String): ZCatalystSelectQuery.Builder .groupBy(columns: Set&lt;Column&gt;): ZCatalystSelectQuery.Builder .orderBy(columns: Set&lt;Column&gt;, sortOrder: ZCatalystUtil.SortOrder): ZCatalystSelectQuery.Builder .innerJoin(tableName: String): ZCatalystSelectQuery.Builder .leftJoin(tableName: String): ZCatalystSelectQuery.Builder .on(joinColumn1: String, comparator: ZCatalystUtil.Comparator, joinColumn2: String): ZCatalystSelectQuery.Builder .or(column: String, comparator: ZCatalystUtil.Comparator, value:String): ZCatalystSelectQuery.Builder .limit(offset: Int, value: Int?): ZCatalystSelectQuery.Builder .build(): ZCatalystSelectQuery A continuación se muestra un fragmento de código de ejemplo de una ejecución de consulta ZCQL: try { ZCQLColumn column1 = ZCQLColumn('Title'); ZCQLColumn column2 = ZCQLColumn('Category'); Set&lt;ZCQLColumn&gt; columns = Set(); columns.add(column1); columns.add(column2); ZCatalystSelectQuery query = ZCatalystQueryBuilder() .select(columns) .from('Projects') .where('Category', Comparator.EQUAL_TO, 'Official') .build(); var (_, result) = await app.getDataStoreInstance().getData(query); print("Query Result: $result"); } on ZCatalystException catch (ex) { print(ex.toString()); } --- ## SDK — iOS — ZCQL -------------------------------------------------------------------------------- title: "Ejecutar consulta ZCQL" description: "ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de creación, recuperación y modificación de datos en Data Store." last_updated: "2026-07-30T07:10:05.749Z" source: "https://docs.catalyst.zoho.com/es/sdk/ios/v2/cloud-scale/zcql/execute-zcql-query/" service: "Cloud Scale" related: - Data Store (/es/cloud-scale/help/data-store/introduction) - ZCQL (/es/cloud-scale/help/zcql/introduction/) - Execute ZCQL - API (/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/#ExecuteZCQLQuery) -------------------------------------------------------------------------------- # ZCQL ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de recuperación de datos en Data Store. Soporta consultas SELECT con funciones integradas, cláusulas SQL Join y otras sentencias y condiciones. ### Ejecutar una consulta ZCQL Antes de ejecutar una consulta ZCQL para obtener el conjunto de datos requerido, debes construir la consulta para pasarla al método **execute()**. Puedes aprender sobre la sintaxis de ZCQL en la página de ayuda de ZCQL. Debes pasar una instancia de **ZCatalystSelectQuery** al método execute(), como se muestra en la sintaxis de código de una ejecución de consulta ZCQL a continuación. &lt;ZCatalystApp&gt;.execute( query : ZCatalystSelectQuery, completion: @escaping (Result&lt;[ [ String : Any ] ], ZCatalystError&gt;) -> Void) **Parámetros**: * **query**: La instancia del tipo ZCatalystSelectQuery a pasar * **completion**: Si la llamada de ejecución de la consulta es exitosa, el bloque de completion devolverá los registros que coincidan con los criterios de la consulta. De lo contrario, devolverá un error. Puedes crear una instancia de query para ZCatalystSelectQuery para las sentencias soportadas por ZCQL, de la siguiente manera: ZCatalystSelectQuery.Builder() .select(columns: Set&lt;Column&gt;) -> ZCatalystSelectQuery.Builder .selectAll() -> ZCatalystSelectQuery.Builder .where(column: String, comparator: Comparator, value: String) -> ZCatalystSelectQuery.Builder .from(tableName: String) -> ZCatalystSelectQuery.Builder .and(column: String, comparator: Comparator, value: String) -> ZCatalystSelectQuery.Builder .groupBy(columns: Set&lt;Column&gt;) -> ZCatalystSelectQuery.Builder .orderBy(columns: Set&lt;Column&gt;, sortOrder: SortOrder) -> ZCatalystSelectQuery.Builder .innerJoin(tableName: String) -> ZCatalystSelectQuery.Builder .leftJoin(tableName: String) -> ZCatalystSelectQuery.Builder .on(joinColumn1: String, comparator: Comparator, joinColumn2: String) -> ZCatalystSelectQuery.Builder .or(column: String, comparator: Comparator, value: String) -> ZCatalystSelectQuery.Builder .limit(offset: Int, value: Int? = nil) -> ZCatalystSelectQuery.Builder .build() -> ZCatalystSelectQuery A continuación se muestra un fragmento de código de ejemplo de una ejecución de consulta ZCQL: func testExecuteZCQL(){ var builder = ZCatalystSelectQuery.Builder() var query = builder.selectAll().from( tableName : "Bio-data" ).build() //Reemplazar con el nombre de tu tabla ZCatalystApp.shared.getDataStoreInstance(tableIdentifier: "1096000000002071").execute( query : query) { ( result ) in switch result{ case .success( let response ) : print("Response : \( response )") case .error( let error ) : print( "Error occurred &gt;&gt;&gt; \( error )" ) } } } --- ## SDK — Java — ZCQL -------------------------------------------------------------------------------- title: "Ejecutar consultas ZCQL" description: "Esta página describe el método para ejecutar consultas ZCQL en una tabla del Data Store en tu aplicación Java con fragmentos de código de ejemplo." last_updated: "2026-07-30T07:10:05.750Z" source: "https://docs.catalyst.zoho.com/es/sdk/java/v1/cloud-scale/zcql/execute-zcql-query/" service: "Cloud Scale" related: - Execute ZCQL queries - API (/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/#ExecuteZCQLQuery) - Execute ZCQL queries (/es/cloud-scale/help/zcql/introduction) - Data Store (/es/cloud-scale/help/data-store/introduction) -------------------------------------------------------------------------------- # ZCQL ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de recuperación, inserción, actualización y eliminación de datos en las tablas del Catalyst Data Store. Puedes ejecutar una variedad de consultas DML usando ZCQL para obtener o manipular datos, y usar varias cláusulas y sentencias como las cláusulas SQL Join, las sentencias Groupby y OrderBy, y funciones SQL integradas. ### Ejecutar consultas ZCQL Catalyst también proporciona una **base de datos OLAP**, además del Data Store principal que es adecuado para consultas analíticas de recuperación de datos. Puedes optar por ejecutar consultas transaccionales simples en el Data Store principal, y consultas analíticas complejas que involucren funciones ZCQL en la base de datos OLAP. Las consultas que ejecutes en el Data Store principal pueden incluir sentencias SELECT, INSERT, UPDATE o DELETE. Las consultas que ejecutes en la base de datos OLAP solo deben incluir la sentencia SELECT, ya que las operaciones de escritura directa no están permitidas. Debes construir una consulta ZCQL y pasarla al método executeQuery() para su ejecución como se muestra en el código de ejemplo a continuación. El método executeQuery() soporta estos tres parámetros: * La variable String que contiene la sentencia de consulta construida * isV2?: Un valor booleano (true o false) que indica si es una consulta ZCQL v2 * isOLAP?: Un valor booleano (true o false) que indica si la consulta necesita ejecutarse en la base de datos OLAP executeQuery(query: string, isV2?: boolean , isOLAP?:boolean) A continuación se muestra una consulta SELECT de ejemplo. La respuesta contendrá los registros que obtengas usando la consulta SELECT, o la respuesta generada para las otras operaciones. #### Fragmento de código de ejemplo <br> import com.zc.component.object.ZCRowObject; import com.zc.component.zcql.ZCQL; //Construir la consulta a ejecutar String query = "SELECT * from empDetails limit 10"; //Obtener la instancia de ZCQL y ejecutar la consulta usando la cadena de consulta ArrayList <ZCRowObject> rowList = ZCQL.getInstance().executeQuery(query, true , false) --- ## SDK — Node JS — ZCQL -------------------------------------------------------------------------------- title: "Obtener instancia de ZCQL" description: "Esta página describe el método para ejecutar consultas ZCQL en una tabla del Data Store en tu aplicación NodeJS con fragmentos de código de ejemplo." last_updated: "2026-07-30T07:10:05.751Z" source: "https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/cloud-scale/zcql/get-component-instance/" service: "Cloud Scale" related: - ZCQL (/es/cloud-scale/help/zcql/introduction) - Data Store (/es/cloud-scale/help/data-store/introduction) -------------------------------------------------------------------------------- # ZCQL ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de recuperación, inserción, actualización y eliminación de datos en las tablas del Catalyst Data Store. Puedes ejecutar una variedad de consultas DML usando ZCQL para obtener o manipular datos, y usar varias cláusulas y sentencias como las cláusulas Join de SQL, sentencias Groupby y OrderBy, y funciones SQL integradas. Catalyst también proporciona una **base de datos OLAP**, además del Data Store principal que es adecuado para consultas de recuperación de datos analíticos. Puedes elegir ejecutar consultas transaccionales simples en el Data Store principal, y consultas analíticas complejas que involucren funciones ZCQL en la base de datos OLAP. ### Get Component Instance Primero debes crear una instancia del componente para ZCQL. La instancia zcql se puede crear como se muestra a continuación. //Obtener una instancia de ZCQL let zcql = app.zcql(); -------------------------------------------------------------------------------- title: "Ejecutar consulta" description: "Esta página describe el método para ejecutar consultas ZCQL en una tabla del Data Store en tu aplicación NodeJS con fragmentos de código de ejemplo." last_updated: "2026-07-30T07:10:05.751Z" source: "https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/cloud-scale/zcql/execute-zcql-query/" service: "Cloud Scale" related: - Execute query - API (/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/#ExecuteZCQLQuery) - ZCQL (/es/cloud-scale/help/zcql/introduction) - Data Store (/es/cloud-scale/help/data-store/introduction) -------------------------------------------------------------------------------- # Ejecutar consulta zcql se refiere a la instancia del componente definida aquí. Esto devolverá una promesa que se resolverá con un objeto. La clave content contendrá el arreglo de objetos de fila. ### Construct and Execute the Query on the Primary Data Store Para las consultas ZCQL que se ejecutan en el Data Store principal, puedes construir la consulta y pasarla al método executeZCQLQuery() como se muestra a continuación. Estas consultas pueden incluir sentencias SELECT, INSERT, UPDATE o DELETE. A continuación se muestra una consulta INSERT de ejemplo: //Construct the query to execute let query = 'INSERT into ShipmentData (productID, productName, region) VALUES (3782, A4 Reams, India)'; let result = await zcql.executeZCQLQuery(query); <br> ### Construct and Execute the Query on the OLAP Database Las consultas que ejecutes en la base de datos OLAP solo deben incluir la sentencia SELECT, ya que no se permiten operaciones de escritura directa en ella. Puedes construir el objeto de consulta y pasarlo al método executeOLAPQuery(). A continuación se muestra una consulta SELECT analítica de ejemplo. //Construct the query to execute let query = 'SELECT SUM(price) FROM ShipmentData'; let result = await zcql.executeOLAPQuery(query); --- ## SDK — Python — ZCQL -------------------------------------------------------------------------------- title: "Obtener instancia de ZCQL" description: "Esta página describe el método para ejecutar consultas ZCQL en una tabla del Data Store en tu aplicación Python con fragmentos de código de ejemplo." last_updated: "2026-07-30T07:10:05.752Z" source: "https://docs.catalyst.zoho.com/es/sdk/python/v1/cloud-scale/zcql/get-component-instance/" service: "Cloud Scale" related: - ZCQL Help (/es/cloud-scale/help/zcql/introduction) - Data Store Help (/es/cloud-scale/help/data-store/introduction) -------------------------------------------------------------------------------- # ZCQL Catalyst Cloud Scale ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de recuperación, inserción, actualización y eliminación de datos en las tablas del Catalyst Cloud Scale Data Store. Puedes ejecutar una variedad de consultas DML usando ZCQL para obtener o manipular datos, y usar varias cláusulas y sentencias como las cláusulas SQL Join, sentencias Groupby y OrderBy, y funciones SQL integradas. Catalyst también proporciona una **base de datos OLAP**, además del Data Store principal que es adecuado para consultas analíticas de recuperación de datos. Puedes elegir ejecutar consultas transaccionales simples en el Data Store principal, y consultas analíticas complejas que involucren funciones ZCQL en la base de datos OLAP. ### Obtener una instancia del componente Una instancia del componente es un objeto que se puede usar para acceder a las configuraciones predefinidas específicas de un componente en particular. Este proceso no realizará una llamada del lado del servidor. La referencia app utilizada en el código a continuación es el objeto Python devuelto como respuesta durante la inicialización del SDK. También ten en cuenta que esta instancia se utilizará en múltiples escenarios al realizar operaciones de recuperación, inserción, actualización o eliminación en el Catalyst Data Store. #Obtener instancia del componente ZCQL zcql_service = app.zcql() -------------------------------------------------------------------------------- title: "Ejecutar consulta" description: "Esta página describe el método para ejecutar consultas ZCQL en una tabla del Data Store en tu aplicación Python con fragmentos de código de ejemplo." last_updated: "2026-07-30T07:10:05.752Z" source: "https://docs.catalyst.zoho.com/es/sdk/python/v1/cloud-scale/zcql/execute-zcql-query/" service: "Cloud Scale" related: - Execute query - API (/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/#ExecuteZCQLQuery) - ZCQL Help (/es/cloud-scale/help/zcql/introduction) - Data Store Help (/es/cloud-scale/help/data-store/introduction) - SDK Scopes (/es/sdk/python/v1/sdk-scopes) -------------------------------------------------------------------------------- # Ejecutar consulta La referencia zcql_service utilizada en el fragmento de código a continuación es la instancia del componente creada anteriormente. Según el objeto de consulta que se pase, la respuesta devuelve un objeto de fila o un array de objetos de fila. ### Construir y ejecutar la consulta en el Data Store principal Para que las consultas ZCQL se ejecuten en el Data Store principal, puedes construir el objeto de consulta y pasarlo al método execute_query() como se muestra a continuación. Estas consultas pueden incluir sentencias SELECT, INSERT, UPDATE o DELETE. A continuación se muestra una consulta INSERT de ejemplo: #Construir la consulta ZCQL query = 'INSERT into ShipmentData (productID, productName, region) VALUES (3782, A4 Reams, India)' result = zcql_service.execute_query(query) ### Construir y ejecutar la consulta en la base de datos OLAP Las consultas que ejecutes en la base de datos OLAP solo deben incluir la sentencia SELECT, ya que las operaciones de escritura directa en ella no están permitidas. Puedes construir el objeto de consulta y pasarlo al método execute_olap_query(). A continuación se muestra una consulta SELECT analítica de ejemplo. //Construct the query to execute query = 'SELECT SUM(price) FROM ShipmentData'; result = zcql_service.execute_olap_query(query); **Parámetros utilizados** <table class="content-table"> <thead> <tr> <th class="w20p">Nombre del parámetro</th> <th class="w20p">Tipo de dato</th> <th class="w60p">Definición</th> </tr> </thead> <tbody> <tr> <td>query</td> <td>String</td> <td>Un parámetro obligatorio. Almacenará la consulta a ejecutar.</td> </tr> </tbody> </table> Info : Consulta la tabla de SDK Scopes para determinar el nivel de permiso requerido para realizar la operación anterior. --- ## SDK — Web — ZCQL -------------------------------------------------------------------------------- title: "Obtener una instancia del componente" description: "ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de recuperación de datos en el Data Store." last_updated: "2026-07-30T07:10:05.752Z" source: "https://docs.catalyst.zoho.com/es/sdk/web/v4/cloud-scale/zcql/get-component-instance/" service: "Cloud Scale" related: - Data Store (/es/cloud-scale/help/data-store/introduction) - ZCQL (/es/cloud-scale/help/zcql/introduction/) - Execute ZCQL - API (/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/#ExecuteZCQLQuery) -------------------------------------------------------------------------------- # ZCQL ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de recuperación, inserción, actualización y eliminación de datos en las tablas del Catalyst Data Store. Puedes ejecutar una variedad de consultas DML usando ZCQL para obtener o manipular datos, y usar varias cláusulas y sentencias como las cláusulas SQL Join, sentencias Groupby y OrderBy, y funciones SQL integradas. ### Obtener una instancia del componente La referencia zcql se puede crear como se muestra a continuación. Esto no realiza una llamada del lado del servidor. //Obtener una instancia de ZCQL var zcql = catalyst.ZCatalystQL; -------------------------------------------------------------------------------- title: "Ejecutar consulta ZCQL" description: "ZCQL es el lenguaje de consulta propio de Catalyst que te permite realizar operaciones de recuperación de datos en el Data Store." last_updated: "2026-07-30T07:10:05.752Z" source: "https://docs.catalyst.zoho.com/es/sdk/web/v4/cloud-scale/zcql/execute-zcql-query/" service: "Cloud Scale" related: - Data Store (/es/cloud-scale/help/data-store/introduction) - ZCQL (/es/cloud-scale/help/zcql/introduction/) - Execute ZCQL - API (/es/api/code-reference/cloud-scale/zcql/execute-zcql-query/#ExecuteZCQLQuery) -------------------------------------------------------------------------------- # Ejecutar consulta ZCQL ### Construir la consulta Debes construir una consulta ZCQL sobre el conjunto de datos requerido antes de ejecutarla. A continuación se muestra una consulta SELECT de ejemplo: //Crear una consulta para ejecutar var query = 'SELECT * FROM ShipmentData'; ### Ejecutar la consulta El objeto de consulta creado en el paso anterior se pasa al método executeZCQLQuery(). La referencia zcql utilizada aquí es la instancia del componente definida anteriormente. Esto devolverá una promesa que se resolverá a un objeto. La clave content contendrá el arreglo de objetos de fila. //Ejecutar la consulta pasándola var zcql = catalyst.ZCatalystQL; var zcqlPromise = zcql.executeQuery(query); zcqlPromise .then((response) => { console.log(response.content); }) .catch((err) => { console.log(err); }); Nota: Para usar los comandos de ZCQL V2 en tu código, usa los métodos de Catalyst listados aquí con los valores listados a continuación para establecer la variable de entorno apropiada:<br /> * Key: ZOHO_CATALYST_ZCQL_PARSER * Value: V2 A continuación se muestra una respuesta de ejemplo que recibirás. La respuesta es la misma para ambas versiones del Web SDK. [ { AlienCity: { CREATORID: "2136000000006003", MODIFIEDTIME: "2021-08-13 13:49:19:475", CREATEDTIME: "2021-08-13 13:49:19:475", CityName: "Dallas", ROWID: "2136000000008508" } }, { AlienCity: { CREATORID: "2136000000006003", MODIFIEDTIME: "2021-08-16 15:55:32:969", CREATEDTIME: "2021-08-16 15:55:32:969", CityName: "Houston", ROWID: "2136000000011002" } }, { AlienCity: { CREATORID: "2136000000006003", MODIFIEDTIME: "2021-08-16 17:03:01:507", CREATEDTIME: "2021-08-16 16:29:10:499", CityName: "Austin", ROWID: "2136000000011011" } } ]