La introducción de datos en JMP es fundamental en el flujo de trabajo analítico, por lo que JMP 18 introduce nuevos conectores de datos para ampliar la gama de fuentes de datos de terceros a las que JMP puede acceder. JMP 18 permite una configuración más detallada de las fuentes de datos ODBC y facilita compartir dichas configuraciones con colegas de diferentes plataformas y publicarlas en JMP Live. Analizamos los conectores de datos, no solo tal como están en JMP 18, sino también los planes para ampliarlos en futuras versiones de JMP.
Buenos días o feliz día, sea cual sea la hora del día que esté viendo esto. Me llamo Neal Siekierski. Soy desarrollador de software en JMP. Soy uno de los desarrolladores principales de nuestra iniciativa Conector de Datos. Estoy aquí hoy para hablar sobre esta iniciativa, lo que significa para JMP 18 y lo que significará en el futuro.
Tenemos estas tres C. Esto es lo que realmente queremos lograr con Data Connect: facilitar la conexión a más fuentes de datos que antes. También queremos que sea posible compartir esas conexiones con mayor facilidad, tanto con compañeros de trabajo que usen la misma plataforma (Mac, Windows o una plataforma diferente) como con JMP Live. Si bien les damos acceso a más fuentes de datos, también queremos que todo esto se pueda hacer en una interfaz común.
Con JMP 18, no pudimos abarcar todo esto, así que nos centramos en ODBC. ODBC es una tecnología que JMP utiliza para comunicarse con fuentes de datos remotas, bases de datos como SQL Server o MySQL, entre otras. Elegimos ODBC porque, al ser un sistema que ya accede a múltiples tipos de bases de datos, había margen para permitir un acceso aún mayor.
Existen algunos obstáculos que actualmente dificultan un poco esta tarea. Esa es otra razón por la que lo analizamos. Por ejemplo, una de las fuentes de dificultades que observamos está en el código SQL. El código SQL es un lenguaje de programación que se utiliza para obtener datos de bases de datos, y JMP tiene que crear ese código, enviarlo a través de la API ODBC para obtener resultados y mostrar los datos.
No todas las bases de datos tienen el mismo código SQL. Por ejemplo, en una base de datos Postgres, obtenemos un par de columnas de una tabla, en este caso, nuestra clase principal favorita. Se vería así. Pero la misma consulta para MySQL y otra base de datos se vería así. Puedes ver Postgres. Usamos comillas dobles, MySQL, comillas invertidas y SQL Server es diferente.
Por este derecho, JMP necesita saber con qué base de datos se comunica. Podemos obtener esa información. Pero para poder usarlo, JMP necesita conocer cada tipo de base de datos. Si JMP no conoce ese tipo de base de datos, tenemos un comportamiento de respaldo específico. Si funciona, ¡genial! Intentamos establecer un conjunto razonable de valores predeterminados, pero podría no funcionar. En ese caso, no se puede usar el Generador de consultas con la fuente de datos.
Otra fuente de dificultad son las cadenas de conexión utilizadas. Para conectarse a una base de datos, JMP debe proporcionar a ODBC una cadena que le indique diversa información sobre dónde se conecta y cómo hacerlo. Una cadena de conexión muy simple se vería así. Por ejemplo, el servidor al que nos conectamos, hasta JMP, es una máquina de prueba a la que tenemos acceso aquí en JMP. Veremos más sobre esto.
Pero lo más importante es que también tenemos un controlador. Un controlador es un software específico que se conecta a ODBC para darte acceso a una fuente de datos específica. ODBC en sí mismo no conoce las fuentes de datos y, al igual que cualquier otro software, no se puede instalar en Mac ni en Windows. O, si lo haces, son dos descargas diferentes. Son dos programas diferentes. Es muy similar para ODBC.
Actual SQL Server es un controlador para SQL Server creado por la empresa Actual y es compatible con Mac. Si tuviera una conexión que usara esta cadena de conexión y quisiera compartirla con otra persona, pero esa persona usara Windows o JMP Live, tendría que cambiarla.
Para ello, necesitarían saber cuál es el controlador de Windows. En este caso, se llama SQL Server. Puedo ejecutarlo en mi equipo Windows y funciona correctamente. Sin embargo, es necesario saber cuál es la base de datos. Es necesario conocer su controlador correspondiente en cada plataforma, lo que dificulta compartirla.
Entre las diferencias entre las bases de datos que requieren JMP, su conocimiento y las diferentes conexiones y cadenas de conexión, puede resultar difícil compartir conexiones y conectar todas las fuentes de datos deseadas.
Para abordar esto, tenemos el marco de conector de datos que hemos introducido internamente en JMP 18, y también tenemos una aplicación específica en ODBC.
La idea central es que hemos tomado todas las opciones que JMP establece internamente según el tipo de conexión. SQL Server es un conjunto de opciones. Postgres necesita otro. Las hemos expuesto todas y las hemos configurado individualmente.
De esta forma, si tienes una base de datos similar a SQL Server en un aspecto, pero quizás diferente en otro, puedes cambiar una opción y funcionará. Esas opciones no son solo elementos del menú de preferencias. Son configuraciones que se pueden nombrar y luego compartir.
Puedes obtener un conjunto completo de configuraciones. Puedes asignarle un nombre. Luego, cuando quieras referenciarlo para conectarte a una base de datos específica, si quieres conectarte a otro lugar, usarías otra. Al tener nombre, también es más fácil compartir esas conexiones.
Finalmente, las configuraciones que realice pueden depender de la plataforma. Acabamos de ver cómo los controladores podrían necesitar ser diferentes u otras configuraciones.
Si necesita una sola cosa en Mac y nada en Windows, es posible. O si tiene algo más específico, incluso podría ser posible. Esas son las ideas principales. Ahora quiero hablar más sobre ellas, pero no lo haré mostrando todo en acción.
Aquí está JMP. Si vamos a la base de datos de archivos, vemos que hay un nuevo elemento de menú: Conectores de datos. Al hacer clic en él, aparece una ventana que, si alguna vez has usado el Generador de consultas, te resultará bastante familiar. Si vamos a Nueva conexión, vemos una lista de configuraciones.
Hay algunas cosas que destacar. Todas las que aparecen arriba son configuraciones predefinidas, por lo que comienzan con com.jmp. Las proporcionamos nosotros. Corresponden a las diversas bases de datos que soportamos internamente y que ahora también hemos expuesto de esta manera.
Quizás no sean directamente útiles para la conexión. No contienen información como la de un servidor ni nada similar, pero sirven como base para crear nuevas configuraciones. Debajo de esto, vemos otras configuraciones.
Algunos de estos los creé yo mismo. Sin embargo, la mayoría no. JMP los creó automáticamente a partir de las conexiones que administra ODBC, llamadas nombres de origen de dominio DNS. Aquí podemos ver una lista de las conexiones, los DNS que tengo en mi Mac, y también vemos varios de ellos en JMP.
Se crean automáticamente para facilitar el inicio. Para terminar, ya que las tenemos en mis conexiones creadas, lo ideal sería hacer clic en "Conectar".
Esto no funciona. Lo que vemos es el mensaje de error del controlador. Indica que no se proporcionó un ID de usuario. JMP no pudo recopilar esa información al convertir esta configuración.
Sin embargo, se nos ofrece la oportunidad. El cuadro de diálogo sugiere crear una nueva configuración para poder usar esta. Añadimos lo necesario, en este caso, un nombre de usuario y una contraseña. Luego, podemos intentar conectarnos. Así que pulsamos "Sí".
Este es el editor de conectores. Hablaremos de ello con más detalle más adelante. Pero por ahora, solo agreguemos la información necesaria. Necesitamos una contraseña. Antes no la había. Ahora tendremos una contraseña. Voy a completarla. También necesitamos un nombre de usuario. La misma idea.
Ahora que hemos completado eso, podemos probar la conexión. Vemos que ha sido exitosa. Ahora que tenemos algo que funciona antes de continuar con la conexión, vamos a guardar una copia. Esto nos ahorrará tener que hacerlo de nuevo más tarde. La configuración indica que hemos configurado la conexión, así que la he guardado. ¡Listo! Para conectar.
Aquí vemos una lista de esquemas. Si selecciono uno de ellos, vemos una lista de tablas. Simplemente seleccionaremos la única clase grande de tabla. Lo más fácil es abrir la tabla; si hacemos clic en "Abrir tabla", veremos que aparece. ¡Genial!
También podemos usar el Generador de consultas. Cierro esto y ahora podemos hacer clic en el botón Generador de consultas. Al aparecer el Generador de consultas, veremos la misma interfaz que antes.
Podemos crear nuestra consulta. Puedo seguir paso a paso. Agregar algunas columnas, ejecutar la consulta y, una vez finalizada, volveremos a ver nuestra tabla. Ahora que tenemos la tabla, hemos visto que todo funciona. Supongamos que lo estamos haciendo correctamente.
Hemos guardado una conexión, así que deberíamos poder usarla. Desconectémosla. Ahora podemos irnos. Podemos encontrar la que guardamos. Podemos conectarnos, así que nos hemos conectado y vemos todo de nuevo.
Abramos nuestra tabla de nuevo. Ahora que la hemos abierto, quizás queramos hacer algo más con ella. Hablé de compartir, tanto con compañeros de trabajo como con JMP Live. Comencemos con la segunda opción y compártala con JMP Live.
Voy a publicar la tabla de datos. Ya está disponible, así que tenemos nuestra tabla. Hagamos clic en "Siguiente". La publicaremos en mi espacio personal, y ahora que está publicada, cerrémosla y vayamos a JMP Live.
Aquí está mi espacio personal. Voy a actualizar. Ahora vemos nuestra tabla, así que ábrela. Espera a que cargue y, si vas a la configuración, tendrás la opción de actualizar los datos con el script. Aquí es donde se aprecia una de las diferencias con el Generador de consultas. Antes necesitábamos una cadena de conexión para configurar un script de actualización. Ahora, si continuamos y usamos el script de origen, veremos algo ligeramente diferente.
No voy a analizar esto mucho ahora. Solo quiero ver si funciona, así que lo guardaré. Asignaré algunas credenciales y luego haré clic en "Actualizar". Veremos si funciona. Falló. Pero veamos por qué. Nos da un error. Es un poco difícil de entender, pero la clave está en que no especificamos un controlador válido.
Analicemos nuestro script con más detalle para entender qué sucede. Si nos fijamos, vemos una línea aquí: "driver actual open source databases". Estamos especificando un controlador. Pero, como ven de nuevo, es uno de esos controladores exclusivos para Mac, así que no es de extrañar que no funcione.
Antes, lo que teníamos que hacer era averiguar el nombre del controlador de Windows, sustituirlo aquí y luego intentarlo de nuevo. Pero en este caso no tengo que averiguarlo. Lo voy a eliminar. Lo voy a guardar y lo intentaremos de nuevo. Parece que funcionó, así que lo volveré a cargar.
Realmente no hay nada diferente que ver aquí. Los datos no cambiaron, pero los vimos actualizados. La razón por la que funcionó es... Revisemos nuestro script de nuevo. Usamos esta configuración integrada. Hemos agregado estos elementos de configuración adicionales para que coincida con la configuración creada por JMP.
En términos generales, cada vez que publicamos JMP en vivo, configuraremos el script de origen para crear algo que sea equivalente a la configuración que usted especificó.
La razón de la diferencia. La razón por la que no usamos simplemente el ID JMP dev para pkg-config es que JMP Live desconoce ese nombre en particular. Para que sea más compatible con JMP Live, estamos creando una configuración equivalente, comenzando con una de las integradas que sabemos que está en JMP Live y añadiendo todo lo demás.
Este integrado hace que todo funcione. Como mencioné, una de las ideas principales de los conectores de datos es que podemos tener una configuración que depende de la plataforma. Vemos que con esta configuración integrada, la configuración integrada de Postgres, buscará automáticamente un controlador adecuado en la plataforma donde se ejecuta.
En mi Mac, encontraría el controlador de bases de datos de código abierto en Windows y el controlador de Postgres para Windows. Todos los controladores integrados funcionan así.
Esto también lo hace. Esto también facilita el uso compartido entre Mac y Windows, y entre máquinas que podrían tener diferentes conjuntos de controladores instalados. Esto es JMP en vivo. Volvamos a JMP y podemos cerrar esto. Desconectemos esto, para empezar de cero. Esa es la configuración. Fue creada por JMP.
Ahora mismo, ¿qué pasaría si quisiéramos crear una configuración nosotros mismos? No queríamos pasar por el administrador ODBC ni pedirle a JMP que la detectara y la mostrara aquí. Analicemos esto a la vez. Hablemos de ello con más detalle. Esta vez, conectémonos a SQL Server. Esa es la configuración de aquí.
Si hago clic en "Nuevo", me permitirá crear una nueva configuración que comience con esta, así que no tengo que especificar todos los detalles del servidor SQL. Solo necesito especificar lo exclusivo de mi conexión. Al abrir esto, verás el editor de nuevo. Ahora, veamos esto con más detalle.
Primero, tenemos el tipo de conexión y JMP 18. Solo tenemos ODBC. Luego, tenemos la base de la conexión; como mencioné, comenzamos con la configuración integrada de SQL Server. Vemos que tenemos SQL Server, nuestra configuración integrada de SQL Server. Específicamente, estamos identificando lo que queremos con ella. Hay otras opciones. Podemos empezar desde cero, solo con los valores predeterminados para ODBC en general.
Podríamos especificar la ruta de un archivo. Incluso podríamos especificar una configuración para usar como base en línea. Pero, en general, esperamos que solo se use otra, como este ID. A continuación, vemos todas las opciones agrupadas. El primer grupo es la información de conexión.
Dónde se conecta, cuáles son sus credenciales. La información que reside en la cadena de conexión para ODBC. Debajo de esto hay otras opciones, por lo que vemos diversas opciones para SQL, y también tenemos opciones solo para la capa ODBC subyacente.
Si voy a "Conexión", queremos establecer una conexión. Voy a completar la información necesaria. La base de datos se llama SQBTest. Pueden ver que, al hacerlo, esta casilla se desmarcó. Esto indica si estamos usando el valor obtenido de esta configuración base.
Ya sea que lo haya cambiado o no, la casilla está desmarcada. Puedo volver a marcarla y volverá al valor original. Pero necesitamos eso. Voy a rellenarlo de nuevo.
Vemos aquí el controlador para compartir hasta JMP 19. Necesito hacerlo, así que lo haremos rápidamente. El valor de la contraseña está ahí. Nuestro servidor será jmpdev2 de nuevo. Tenemos nuestro nombre de usuario. Veamos si se conecta. Sí, se conecta. Pero antes de continuar, consideremos un escenario. Supongamos que no me estoy conectando a SQL Server. Digamos que es algo muy similar a SQL Server, pero no exactamente idéntico.
La diferencia radica en que, si recuerdas, SQL Server usa corchetes. Digamos que usa comillas dobles, como Postgres. Si analizamos todas estas opciones de SQL, veremos muchas diferencias. Pero veamos el tipo de comillas. Mira, actualmente se especifica como corchetes. Si lo cambio a comillas dobles, sabremos que cumpliremos con lo que necesita nuestra base de datos.
Para esta demostración, SQL Server admite ambos. Los corchetes son su función nativa, pero las comillas dobles son más comunes. Dado que admite ambos, veremos esto en acción. Guardemos esto. Será mi SQL Server. Conectémonos.
Antes de poder ver las tablas que tenemos, podemos seleccionar una clase, por ejemplo. Si revisamos el Constructor de Consultas, veremos que el código SQL generado refleja nuestra elección.
Normalmente, de nuevo, se esperaría que las comillas estuvieran entre corchetes. Pero ahora tenemos las comillas dobles. También podemos ver que esto funciona. Si ejecuto la consulta, obtenemos nuestra tabla. De nuevo, he creado una configuración no necesariamente desde cero, sino a partir de la base. Solo he tenido que proporcionar algunas opciones y ahora tengo una conexión completamente funcional.
Incluso pude ajustar un poco el comportamiento. Ya he hecho todo este trabajo. ¿Qué pasa si alguien más de mi organización quiere aprovecharlo? Es posible compartir estas conexiones no solo con JMP Live, como mostré, sino también con otros.
Para ello, tenemos este pequeño menú triangular rojo. Si hacemos clic en él, veremos una opción para compartir conectores. Voy a abrirla. Pueden ver una lista de nuestras configuraciones a la izquierda. Las que tenemos aquí excluyen las integradas porque no es necesario compartirlas.
Si seleccionamos nuestra configuración, la veremos aparecer aquí a la derecha. Hice doble clic para hacerlo, pero también tenemos estos botones; puedo hacer clic en este para moverla o, mejor dicho, eliminarla. Hago clic en este para volver a añadirla. Para compartir, vamos a crear un complemento. Usaremos la función de añadir de JMP para distribuir estas configuraciones y facilitar su instalación.
Pero como es un complemento, todos necesitan un ID. Para eso está este cuadro de abajo. Por defecto, se usa el nombre de host de tu máquina con los subcomponentes invertidos. La dirección de mi máquina es mh382.mmt.com. La hemos modificado a com.sas.mmt.mh302. Esa será la base. Luego, como solo he añadido una configuración, usará su nombre. Pero si añadiera otra, por ejemplo, solo serían conectores de datos.
Pero eliminemos eso. Hagamos clic en Guardar. El nombre predeterminado es el ID completo más el complemento JMP. Pero no es necesario. Podemos hacerlo más intuitivo, así que lo llamaremos Servidor. De hecho, podemos hacerlo un poco mejor. No tenemos que usar este nombre predefinido. Simplemente eliminémoslo. Cambiemos el nombre. Por ejemplo, si fuera empresa, usaremos mi nombre de usuario. En lugar de usar este nombre de nuevo, indicaremos cuál es nuestro propósito para la Conferencia Discovery de este año.
Pulsa "Guardar". Le cambiaremos el nombre a algo más intuitivo. Guárdalo y ahora se nos pregunta si queremos conservar la contraseña. Como sabemos que no querrás compartir tu contraseña con nadie, hemos encontrado una opción para eliminarla automáticamente. En este caso, eliminemos la contraseña.
Pueden ver que está guardado. Vemos que mi escritorio ahora tiene este complemento. Pero ahora, ¿qué hacemos con él? Bueno, tienes que asignarlo a otra persona. En este caso, en lugar de asignarme a otra persona, me lo asignaré a mí mismo. Pero en Windows. Cambiemos a Windows. Tenemos que iniciar sesión aquí rápidamente, y aquí estamos. Aquí está JMP. Necesitamos encontrar este complemento donde está mi carpeta de descargas. Ahora tengo este complemento, justo si lo abro y lo instalo.
Bien, ahora veamos en acción: vamos a Archivo, Base de datos, Conectores de datos. Abriremos nuestras configuraciones. Vemos que aquí está. Intenta conectarte. Vemos que no se pudo conectar porque falló el inicio de sesión. Tiene sentido. Cambiamos nuestra contraseña. Digamos que sí, queremos configurarla un poco más. Volvemos a agregar la contraseña. Puedes probarlo. Verifica que funcione. Pulsamos Aceptar. Vemos que nos hemos conectado.
Hemos creado [inaudible 00:26:10] Mac. Lo hemos trasladado a Windows y podemos conectarlo. Veremos que todo funciona igual: compartir, configuraciones desde cero. Pero, ¿cómo funciona todo esto? Volvamos a JMP. Lo vemos en la configuración integrada de SQL Server. Vemos las otras configuraciones que hemos creado.
¿Cómo son? ¿Dónde se encuentran? Las configuraciones integradas se encuentran en una carpeta que forma parte de la instalación de JMP, pero las que usted crea se guardarán en el área de datos de usuario de JMP junto con el resto de sus datos. Si navego a la carpeta de la biblioteca en mi carpeta de usuario en Mac, voy a Soporte de aplicaciones y JMP en Windows.
Esta es una carpeta dentro de App Data. Puedes ver que, junto con otra información específica de JMP, tenemos información específica de la versión. También tenemos información de Python. También tenemos una carpeta de conectores de datos.
Si lo abro, veo archivos que corresponden a todas las configuraciones que he realizado y a los JMP creados desde ODBC. Por ejemplo, si revisamos esta configuración del servidor MySQL, tenemos una extensión JMP DC que significa conector de datos JMP. Además de todos estos archivos JMP DC, también tenemos el archivo JMPDataConnectorRegistry.JSON. Este archivo, que contiene información sobre todos estos datos, asigna el nombre del servidor MySQL, por ejemplo, a este archivo específico.
También puede contener otra información. Pero veamos qué contiene. Vamos a usar un editor de texto por ahora; perdón, no era el correcto. He nombrado dos muy similares, así que vamos a abrir este. Lo que vemos es mucho texto que parece JSL, y eso se debe a que es JSL, o mejor dicho, un subconjunto de JSL.
Aquí tenemos, a la izquierda, los nombres de nuestras opciones y a la derecha, sus valores. Esta primera línea es especial. Indica que nuestra base es la que se identificará mediante com.JMP.SQLServer. Podemos ver su configuración. Vemos que este servidor que configuramos es su base de datos, nuestra modificación del tipo pro.
En general, los nombres de las opciones a la izquierda se corresponden con el contenido del editor. A la derecha, tenemos los valores que se asemejan al contenido del editor. Aquí no tenemos el pequeño texto al final que da un ejemplo. En particular, para el nombre de usuario y la contraseña, tenemos estas cadenas codificadas. Las hemos almacenado así para que no se almacenen directamente el nombre de usuario y la contraseña.
Pero JMP pudo conectar con todos ellos de la misma manera, y como mencioné, esto es JSL. Una forma de verlo es si queremos agregar una configuración específica para cada plataforma; lo hemos visto con las integradas. Pero si queremos hacerlo nosotros mismos, por ejemplo, elijamos una opción que aún no hemos mencionado: la obtención de bloques. Es algo que facilita la obtención de datos si se puede habilitar, pero a veces no es compatible o no funciona correctamente.
Digamos que funciona en mi Mac, pero no en Windows. Queremos tenerlo activado para Windows y Mac, pero desactivado en caso contrario. Con una línea como esta, donde he configurado la opción "Obtención de bloque" en esta expresión JSL, se obtendrá el efecto deseado, ya que todos los valores de la derecha son solo código JSL.
Cada vez que JMP cargue esta configuración, la evaluará. Dirá "Sí", en este caso, estamos en una Mac. Tendremos activada la obtención de bloques. Así es como funcionará. Sí, y en JMP se puede usar JSL para trabajar con esto. Cerremos esto porque ya no es un problema.
Cerremos todo esto. Volvemos a JMP. Abramos un editor de scripts. Es repetitivo. ¿Qué puedo hacer? Bueno, puedo cargar la configuración desde un archivo. Estará en el conector de datos de memoria. De nuevo, veamos... Hemos estado trabajando con este servidor MySQL. Esta línea lo cargará. Nos dará esa configuración. Luego puedo hacer cosas como obtener valores específicos, para poder obtener la opción de obtención de bloques que configuramos.
O podría obtener el tipo de comillas. Puedo cambiar las opciones para restablecer el tipo de comillas al valor anterior, que son corchetes. Podría simplemente desactivar la Obtención de bloque. Ahora podemos imprimirlo de nuevo para comprobar si tiene el efecto deseado. Si ejecuto todo esto, vemos que la Obtención de bloque está activada. El tipo de comillas es doble. Después de configurarlo, todo está desactivado.
Esto es parte de lo que puedes hacer para manipularlo. Si analizamos todo el conjunto, veremos todos los valores que no son los predeterminados. Por ejemplo, vemos nuestro nombre de usuario y contraseña. Pero también vemos muchas otras opciones donde SQL Server es diferente del predeterminado. Observa todo eso. El registro. Esa asignación de nombres a configuraciones reales también es accesible mediante JSL.
Tengo una variable aquí. Puedo, por ejemplo, obtener todas las entradas disponibles. Esto mostrará tanto las que creamos como las integradas en JMP. Si lo hiciéramos en Windows, también veríamos la que se instaló mediante el complemento. Podemos obtener metadatos sobre una entrada en particular. Podemos revisar la configuración que creamos aquí. Esta nos indicará el nombre y la ruta. Esta información es esencial, pero también incluye el tipo y, al ser ODBC, también incluirá el controlador.
También puedes registrar una configuración para JSL. Digamos que queremos escribir la nuestra y la llamaremos MySQLServer2DC. Hemos añadido una nueva variable de ruta. Para quienes ya la conozcan, esta apunta directamente a la carpeta de conectores de datos que mostré antes. Puedo escribir texto allí.
Vamos a simplificarlo. Empezaremos con nuestra configuración base, este servidor MySQL. Restableceremos, por ejemplo, el tipo de archivo. Ahora tengo esto. Finalmente, siguiendo mi ruta, lo registraré. El nombre coincidirá con el nombre del archivo, como hicimos con los demás. Luego, la ruta. Ruta. Si ejecuto todo esto, podemos intentar cargarlo.
Aquí haremos lo mismo que antes, pero con ambos. Podemos ver que funciona, que imprime algo aquí. Incluso podríamos obtener el valor que cambiamos. Vean que está ahí. Bien, de nuevo, ya lo hemos visto, y ambos podemos usar JSL para manipular las configuraciones. Si deseamos trabajar con esas configuraciones directamente, podemos ver dónde se encuentran en el sistema de archivos y agregar la configuración específica de la plataforma.
He hablado mucho. Resumamos un poco. Volvamos al principio. Dije que teníamos objetivos específicos para esta iniciativa. Bien, veámoslos uno por uno. El primero era que sería posible conectarse a más fuentes de datos. Para JMP 18, ampliamos el acceso a las fuentes de datos dentro de ODBC. Espero que, por ejemplo, al cambiar el tipo JSON para SQL Server, les haya dado una idea de lo que es posible.
Hemos mejorado la compatibilidad con sus fuentes de datos. En cuanto al uso compartido, espero que mostrar la compatibilidad de JMP Live con Windows haya dejado claro lo que podemos hacer. Por fin, una interacción más uniforme. Esto es algo que no habíamos visto antes. Les mostré una nueva interfaz. Les mostré algo que solo funciona con ODBC. Es importante recordar que nos centramos en ODBC y que estábamos sentando las bases para otras cosas. Esto es algo que veremos en el futuro.
Hablando del futuro de JMP 18.1, tenemos algunas mejoras menores planeadas, principalmente para el editor. En JMP 19, tendremos más mejoras en el editor. Pero creo que, aún más importante, tendremos nuevos tipos de conexiones. Tomaremos algo que actualmente solo está disponible para ODBC, pero también lo expandiremos a otras funciones. La primera que quiero mencionar es SAS.
En JMP 18, tuvimos que eliminar la conectividad SAS. Pero en JMP 19 la recuperamos y se integrará en este marco de conexión de datos. Esto significa que se mantendrá la misma interfaz para conectar el mismo editor para editar configuraciones y la misma capacidad para compartirlas, como con los complementos. También añadiremos conectividad con Amazon S3 y Microsoft SharePoint. Algo que creo que se ha estado solicitando desde hace tiempo.
Lo interesante de estos dos, s3 y SharePoint, es que no se distribuirán con JMP. En cuanto a SAS, buscamos algo similar a lo que teníamos antes de JMP 18. Se distribuirá con JMP. Tendrás acceso a muchas de las funcionalidades de GSL que ya existían.
Para S3 y SharePoint, no se incluirán en el paquete JMP, sino que se distribuirán a través de la plataforma JMP Marketplace. Algunos de ustedes quizá ya hayan oído hablar de ello. Si no, probablemente lo encontrarán en Discovery.
En resumen, será una forma de distribuir extensiones a JMP. Distribuiremos la conectividad con S3 y SharePoint de esa manera. Para que funcionen con JMP, definiremos una API de Python, expuesta desde JMP, que pueda usarse para interactuar con todo lo necesario para conectarse a ese marco de conexión y, posteriormente, acceder al Generador de Consultas y más allá.
Para implementarlos, usamos esa interfaz y también bibliotecas de Python existentes. Esto forma parte de la maravilla del ecosistema Python y también es fruto del trabajo que hemos realizado para mejorar la integración de Python con JMP 18. Pero no es algo exclusivo de nosotros.
Esa interfaz es algo que vamos a exponer y documentar, y les permitirá saber no solo a nosotros, sino también a ustedes crear nuevos tipos de conexiones e integrarlas con JMP y el Generador de Consultas. Pueden usar las mismas herramientas.
Eso es lo que haremos en el futuro. Es básicamente todo lo que tengo. Quiero reiterar que espero que lo que hemos hecho en 18, ya saben, no solo haya sentado las bases para futuras mejoras como las que estoy comentando, sino que también proporcione una mejora convincente de lo que podemos hacer con ODBC.
Que es posible conectarse a más fuentes de datos y compartir esas conexiones con mayor facilidad. De nuevo, creo que el futuro será aún mejor en cuanto a lo que podemos hacer. Espero con interés lo que podamos lograr allí. Dicho esto, quiero agradecerles su atención y espero que disfruten del resto del descubrimiento.
