He estado utilizando Generador de consultas y Archivo->Conectar a->ODBC->Abrir tabla de base de datos para obtener datos de una base de datos PostgreSQL.
La tabla que obtengo de la base de datos contiene una columna con cadenas de texto largas.
Mis cadenas de texto se recortan cuando superan una longitud de 524.587. (2^19 -1)
¿Existe alguna configuración en JMP y/o JSL que pueda modificar para habilitar la consulta de cadenas de texto más largas?
Situación que motivó el problema y hallazgos de la depuración
He estado explorando las capacidades del complemento Torch Deep Learning .
He descargado un conjunto de datos de Kaggle sobre perros contra lobos .
Utilicé la función Importar varios archivos de JMP para crear una tabla de datos que contiene todos estos archivos (2000 archivos).
Utilicé JMP para limpiar los datos, crear una columna de respuesta y columnas de validación, etc.
Creé una base de datos, un esquema y una tabla en PostgreSQL.
Utilicé JMP para conectarme a la tabla de la base de datos, concatené mis datos de Perros vs Lobos y guardé la información de nuevo en la base de datos. La columna de la imagen se guarda como texto en la base de datos usando new image( char to blob("....la información de la imagen...") ).
He revisado los datos de la base de datos y todo parece estar correcto.
Utilicé Query Builder para conectarme a mi base de datos y consultar toda la tabla Dogs vs Wolves.
Convertí la columna "Imagen" del tipo de datos Carácter a Expresión para que las imágenes se mostraran en la tabla de datos. De las 2000 entradas, 1986 funcionan como se esperaba. 14 de las imágenes no se muestran correctamente. Estas entradas incluyen las siguientes imágenes:
- lobos/nombres-de-lobo-e1528831052890.jpg
- lobos/cachorros de lobo.jpg
- lobos/wolf-4191896__480.png
- lobos/pexels-foto-682375.jpeg
- lobos/pexels-foto-682361.jpeg
- lobos/naturaleza-animal-lobo-naturaleza salvaje.jpg
- lobos/michael-mazzone-xvLRLLfP22o-unsplash.jpg
- lobos/hero_gray_wolf_animals.jpg
- lobos/gray-wolf_thumbJPG.jpg
- lobos/lobo-gris.jpg
- lobos/Winter-wolf-snow_-_West_Virginia_-_ForestWander.jpg
- lobos/SRX_WOLF_TRAPPING1.JPG.jpg
- lobos/lobo_eurasiáticoJPG.jpg
- perros/n02106382_3756.jpg
He revisado la información de las imágenes y he descubierto que las filas con problemas no contienen toda la información. Las entradas terminan a mitad de la información de la imagen.
He revisado la longitud de la información de la imagen y he descubierto que todas las imágenes corruptas tienen una longitud de caracteres de exactamente 524.287. (2^19 - 1).
He intentado modificar los parámetros JSL creados por Query Builder, pero no he logrado solucionar el problema de la longitud del texto. No soy experto en SQL, así que espero que al cambiar alguna de estas configuraciones pueda resolver mi problema.
New SQL Query(
Connection(
"
ODBC:AB=0;
BATCHSIZE=100;
BI=0;
BOOLSASCHAR=0;
BYTEAASLONGVARBINARY=1;
COMMLOG=2;
CONNSETTINGS=;
D6=-101;
DEBUG=2;
DRIVER={PostgreSQL Unicode(x64)};
EXTRASYSTABLEPREFIXES=;
FAKEOIDINDEX=0;
FETCH=100;
FETCHREFCURSORS=0;
IGNORETIMEOUT=0;
KEEPALIVEINTERVAL=-1;
KEEPALIVETIME=-1;
LFCONVERSION=1;
LOWERCASEIDENTIFIER=0;
MAXLONGVARCHARSIZE=8092;
MAXVARCHARSIZE=255;
OPTIONALERRORS=0;
PARSE=0;
PQOPT=;
PROTOCOL=7.4;
READONLY=0;
ROWVERSIONING=0;
SHOWOIDCOLUMN=0;
SHOWSYSTEMTABLES=0;
SSLMODE=disable;
TEXTASLONGVARCHAR=0;
TRUEISMINUS1=0;
UNIQUEINDEX=1;
UNKNOWNSASLONGVARCHAR=0;
UNKNOWNSIZES=0;
UPDATABLECURSORS=1;
USEDECLAREFETCH=1;
USESERVERSIDEPREPARE=1;
XAOPT=1;
"
),
QueryName( "dogs_v_wolves" ),
Select(
Distinct,
Column( "Picture", "t1" ),
Column( "Label", "t1" ),
Column( "File Path", "t1" ),
Column( "Short File Name", "t1" ),
Column( "FoldA", "t1" ),
Column( "FoldB", "t1" ),
Column( "FoldC", "t1" ),
Column( "Validation", "t1" )
),
From( Table( "dogs_v_wolves", Schema( "dogs_v_wolves" ), Alias( "t1" ) ) )
) << Run;
He intentado modificar los parámetros JSL creados por Open Database Table, pero no he logrado solucionar el problema del recorte de la longitud del texto. Repito, no soy un experto en SQL, así que espero que al cambiar alguna de estas configuraciones pueda resolver mi problema.
Open Database(
"
AB=0;
BATCHSIZE=100;
BI=0;
BOOLSASCHAR=0;
BYTEAASLONGVARBINARY=1;
COMMLOG=2;
CONNSETTINGS=;
D6=-101;
DEBUG=2;
DRIVER={PostgreSQL Unicode(x64)};
EXTRASYSTABLEPREFIXES=;
FAKEOIDINDEX=0;
FETCH=100;
FETCHREFCURSORS=0;
IGNORETIMEOUT=0;
KEEPALIVEINTERVAL=-1;
KEEPALIVETIME=-1;
LFCONVERSION=1;
LOWERCASEIDENTIFIER=0;
MAXLONGVARCHARSIZE=8092;
MAXVARCHARSIZE=255;
OPTIONALERRORS=0;
PARSE=0;
PQOPT=;
PROTOCOL=7.4;
READONLY=0;
ROWVERSIONING=0;
SHOWOIDCOLUMN=0;
SHOWSYSTEMTABLES=0;
SSLMODE=disable;
TEXTASLONGVARCHAR=0;
TRUEISMINUS1=0;
UNIQUEINDEX=1;
UNKNOWNSASLONGVARCHAR=0;
UNKNOWNSIZES=0;
UPDATABLECURSORS=1;
USEDECLAREFETCH=1;
USESERVERSIDEPREPARE=1;
XAOPT=1;
",
"SELECT * FROM dogs_v_wolves.dogs_v_wolves"
);
Para investigar más a fondo la situación, creé un script de Python que ejecuta una consulta SQL y guarda los resultados en un dataframe de pandas. Luego, creé un archivo JSL que ejecuta el script de Python y convierte el dataframe de pandas en una tabla de datos JMP.
El archivo python se llama "sqlQuery.py" y contiene:
import pandas as pd
import sqlalchemy as db
engine = db.create_engine("postgresql+psycopg2://##connection information##")
query = """
SELECT DISTINCT *
FROM dogs_v_wolves.dogs_v_wolves;
"""
df = pd.read_sql_query(query, engine)
El archivo JSL contiene:
Names Default To Here( 1 );
pythonFilePath = "sqlQuery.py";
Python Submit File( pythonFilePath );
dt = python get(df);
dt:Picture << set data type(expression);
Al ejecutar este código, la tabla de datos contiene las cadenas de texto completas. Al convertir la columna Picture a un tipo de datos Expression, las imágenes se muestran correctamente.
Conclusiones
JMP está escribiendo correctamente cadenas de texto largas en la base de datos.
JMP recorta las cadenas de texto largas al realizar consultas en la base de datos mediante Query Builder y/o Open Database Table.
Al ejecutar una consulta SQL fuera de JMP, se obtienen las cadenas de texto completas que están almacenadas en la base de datos.
Deseo
Me gustaría poder aprovechar la comodidad de Query Builder mientras trabajo en mis proyectos de procesamiento de imágenes.
Pregunta
¿Existe alguna configuración en JMP y/o JSL que pueda modificar para habilitar la consulta de cadenas de texto más largas?
No había probado el conector de datos de PostgreSQL. Solo estaba usando la conexión ODBC integrada.
Siguiendo su recomendación, he probado el conector de datos de PostgreSQL y puedo confirmar que este método resuelve el problema del recorte de textos largos.
Sabía que debía haber una solución sencilla, pero no pude encontrarla por mi cuenta.
Gracias por la orientación.
Podría haber una solución con ODBC, pero podría requerir un poco más de investigación, ya que supongo que esto afectaría los datos que obtiene.
MAXLONGVARCHARSIZE=8092;
MAXVARCHARSIZE=255;
TEXTASLONGVARCHAR=0;
y claramente no coinciden con su 524287, por lo que lo más probable es que se esté sobrescribiendo en otro lugar (aunque sigue siendo demasiado pequeño para su caso de uso).
@briancorcoran
Ahí es precisamente donde me quedé atascado. Me centré demasiado en parámetros como:
BOOLSASCHAR=0;
BYTEAASLONGVARBINARY=1;
MAXLONGVARCHARSIZE=8092;
MAXVARCHARSIZE=255;
TEXTASLONGVARCHAR=0;
UNKNOWNSASLONGVARCHAR=0;
UNKNOWNSIZES=0;
Pero incluso con la ayuda de ChatGPT y Claude, no pude encontrar ningún parámetro que afectara el límite de longitud de la cadena de texto que estaba obteniendo. Probé muchas combinaciones de configuraciones recomendadas por las IA.
ChatGPT me ayudó a crear el código Python que utilicé para mi consulta SQL básica que proporcioné en mi publicación inicial, pero nunca me recomendó usar el conector de datos de PostgreSQL.
Aunque podría haberlo hecho con mi propia consulta SQL en Python, me parecía que estaba reinventando la rueda y nunca sería tan fácil como debería ser.
Quieres desactivar la obtención de bloques
Preferences(ODBC Disable Block Fetch(1))
Utilizar JSL antes de conectarse a la fuente de datos ODBC.
JMP utiliza la recuperación de bloques para mejorar el rendimiento al importar datos desde fuentes ODBC.
La recuperación de bloques consiste en un bloque de memoria contiguo de N x N que se rellena con cada lectura de la fuente de datos, en lugar de línea por línea. Con grandes cantidades de datos de caracteres, este bloque se recortará. Al activar esta preferencia, JMP leerá la cadena completa línea por línea.
He probado esta recomendación y, lamentablemente, no parece funcionar.
Ejecuté el código jsl y luego consulté mi tabla usando Archivo -> Conectar a -> ODBC -> Abrir tabla de base de datos.
A pesar del cambio de preferencias, sigo viendo cómo las cadenas de texto largas se recortan a una longitud de 524.287 caracteres.
