Spring/spring-tools
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

PostgreSQL syntax highlighting and validation

Browse Source
This commit is contained in:
aboyko
2024-07-10 09:43:17 -04:00
parent 98d1301a30
commit fcbd052bf4
30 changed files with 66614 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
headless-services/commons/jpql/.gitignore vendored
View File

@@ -11,6 +11,10 @@
/src/main/java/org/springframework/ide/vscode/parser/mysql/MySqlParser.tokens
/src/main/java/org/springframework/ide/vscode/parser/mysql/MySqlLexer.interp
/src/main/java/org/springframework/ide/vscode/parser/mysql/MySqlLexer.tokens
/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.interp
/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.tokens
/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.interp
/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.tokens
/src/main/java/org/springframework/ide/vscode/parser/spel/SpelParser.interp
/src/main/java/org/springframework/ide/vscode/parser/spel/SpelParser.tokens
/src/main/java/org/springframework/ide/vscode/parser/spel/SpelLexer.interp

1
headless-services/commons/jpql/generate-parsers.sh
View File

@@ -10,4 +10,5 @@ java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar Jpql.g4 -o ${workdir}/src/main/j
java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar Hql.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/hql -package org.springframework.ide.vscode.parser.hql
java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar MySqlLexer.g4 MySqlParser.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/mysql -package org.springframework.ide.vscode.parser.mysql
java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar SpelLexer.g4 SpelParser.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/spel -package org.springframework.ide.vscode.parser.spel
java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar PostgreSqlLexer.g4 PostgreSqlParser.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/postgresql -package org.springframework.ide.vscode.parser.postgresql

936
headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 Normal file
View File

@@ -0,0 +1,936 @@
// The MIT License
// Copyright 2018 Tal Shprecher
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
lexer grammar PostgreSqlLexer;
// Skip
WHITESPACE : [ \t\r\n]+ -> skip;
BLOCK_COMMENT : '/*' .*? '*/' -> channel(HIDDEN);
LINE_COMMENT : '--' .*? '\n' -> channel(HIDDEN);
// Fragments
fragment A : ('A'|'a') ;
fragment B : ('B'|'b') ;
fragment C : ('C'|'c') ;
fragment D : ('D'|'d') ;
fragment E : ('E'|'e') ;
fragment F : ('F'|'f') ;
fragment G : ('G'|'g') ;
fragment H : ('H'|'h') ;
fragment I : ('I'|'i') ;
fragment J : ('J'|'j') ;
fragment K : ('K'|'k') ;
fragment L : ('L'|'l') ;
fragment M : ('M'|'m') ;
fragment N : ('N'|'n') ;
fragment O : ('O'|'o') ;
fragment P : ('P'|'p') ;
fragment Q : ('Q'|'q') ;
fragment R : ('R'|'r') ;
fragment S : ('S'|'s') ;
fragment T : ('T'|'t') ;
fragment U : ('U'|'u') ;
fragment V : ('V'|'v') ;
fragment W : ('W'|'w') ;
fragment X : ('X'|'x') ;
fragment Y : ('Y'|'y') ;
fragment Z : ('Z'|'z') ;
fragment HEX_DIGIT : [0-9A-F];
fragment DEC_DIGIT : [0-9];
fragment DQUOTA_STRING : '"' ( '\\'. | '""' | ~('"' | '\\') )* '"';
fragment SQUOTA_STRING : '\'' ('\\'. | '\'\'' | ~('\'' | '\\'))* '\'';
fragment BQUOTA_STRING : '`' ( '\\'. | '``' | ~('`' | '\\'))* '`';
// Keywords
A_ : A;
ABORT : A B O R T;
ABS : A B S;
ABSOLUTE : A B S O L U T E;
ACCESS : A C C E S S;
ACTION : A C T I O N;
ADA : A D A;
ADD : A D D;
ADMIN : A D M I N;
AFTER : A F T E R;
AGGREGATE : A G G R E G A T E;
ALIAS : A L I A S;
ALL : A L L;
ALLOCATE : A L L O C A T E;
ALSO : A L S O;
ALTER : A L T E R;
ALWAYS : A L W A Y S;
ANALYSE : A N A L Y S E;
ANALYZE : A N A L Y Z E;
AND : A N D;
ANY : A N Y;
ARE : A R E;
ARRAY : A R R A Y;
AS : A S;
ASC : A S C;
ASENSITIVE : A S E N S I T I V E;
ASSERTION : A S S E R T I O N;
ASSIGNMENT : A S S I G N M E N T;
ASYMMETRIC : A S Y M M E T R I C;
AT : A T;
ATOMIC : A T O M I C;
ATTRIBUTE : A T T R I B U T E;
ATTRIBUTES : A T T R I B U T E S;
AUTHORIZATION : A U T H O R I Z A T I O N;
AVG : A V G;
BACKWARD : B A C K W A R D;
BEFORE : B E F O R E;
BEGIN : B E G I N;
BERNOULLI : B E R N O U L L I;
BETWEEN : B E T W E E N;
BIGINT : B I G I N T;
BINARY : B I N A R Y;
BIT : B I T;
BIT_LENGTH : B I T '_' L E N G T H;
BITVAR : B I T V A R;
BLOB : B L O B;
BOOLEAN : B O O L E A N;
BOTH : B O T H;
BREADTH : B R E A D T H;
BUFFERS : B U F F E R S;
BY : B Y;
C_ : C;
CACHE : C A C H E;
CALL : C A L L;
CALLED : C A L L E D;
CARDINALITY : C A R D I N A L I T Y;
CASCADE : C A S C A D E;
CASCADED : C A S C A D E D;
CASE : C A S E;
CAST : C A S T;
CATALOG : C A T A L O G;
CATALOG_NAME : C A T A L O G '_' N A M E;
CEIL : C E I L;
CEILING : C E I L I N G;
CHAIN : C H A I N;
CHAR : C H A R;
CHAR_LENGTH : C H A R '_' L E N G T H;
CHARACTER : C H A R A C T E R;
CHARACTER_LENGTH : C H A R A C T E R '_' L E N G T H;
CHARACTER_SET_CATALOG : C H A R A C T E R '_' S E T '_' C A T A L O G;
CHARACTER_SET_NAME : C H A R A C T E R '_' S E T '_' N A M E;
CHARACTER_SET_SCHEMA : C H A R A C T E R '_' S E T '_' S C H E M A;
CHARACTERISTICS : C H A R A C T E R I S T I C S;
CHARACTERS : C H A R A C T E R S;
CHECK : C H E C K;
CHECKED : C H E C K E D;
CHECKPOINT : C H E C K P O I N T;
CLASS : C L A S S;
CLASS_ORIGIN : C L A S S '_' O R I G I N;
CLOB : C L O B;
CLOSE : C L O S E;
CLUSTER : C L U S T E R;
COALESCE : C O A L E S C E;
COBOL : C O B O L;
COLLATE : C O L L A T E;
COLLATION : C O L L A T I O N;
COLLATION_CATALOG : C O L L A T I O N '_' C A T A L O G;
COLLATION_NAME : C O L L A T I O N '_' N A M E;
COLLATION_SCHEMA : C O L L A T I O N '_' S C H E M A;
COLLECT : C O L L E C T;
COLUMN : C O L U M N;
COLUMN_NAME : C O L U M N '_' N A M E;
COMMAND_FUNCTION : C O M M A N D '_' F U N C T I O N;
COMMAND_FUNCTION_CODE : C O M M A N D '_' F U N C T I O N '_' C O D E;
COMMENT : C O M M E N T;
COMMIT : C O M M I T;
COMMITTED : C O M M I T T E D;
COMPLETION : C O M P L E T I O N;
CONDITION : C O N D I T I O N;
CONDITION_NUMBER : C O N D I T I O N '_' N U M B E R;
CONFIGURATION : C O N F I G U R A T I O N;
CONFLICT : C O N F L I C T;
CONNECT : C O N N E C T;
CONNECTION : C O N N E C T I O N;
CONNECTION_NAME : C O N N E C T I O N '_' N A M E;
CONSTRAINT : C O N S T R A I N T;
CONSTRAINT_CATALOG : C O N S T R A I N T '_' C A T A L O G;
CONSTRAINT_NAME : C O N S T R A I N T '_' N A M E;
CONSTRAINT_SCHEMA : C O N S T R A I N T '_' S C H E M A;
CONSTRAINTS : C O N S T R A I N T S;
CONSTRUCTOR : C O N S T R U C T O R;
CONTAINS : C O N T A I N S;
CONTINUE : C O N T I N U E;
CONVERSION : C O N V E R S I O N;
CONVERT : C O N V E R T;
COPY : C O P Y;
CORR : C O R R;
CORRESPONDING : C O R R E S P O N D I N G;
COSTS : C O S T S;
COUNT : C O U N T;
COVAR_POP : C O V A R '_' P O P;
COVAR_SAMP : C O V A R '_' S A M P;
CREATE : C R E A T E;
CREATEDB : C R E A T E D B;
CREATEUSER : C R E A T E U S E R;
CROSS : C R O S S;
CSV : C S V;
CUBE : C U B E;
CUME_DIST : C U M E '_' D I S T;
CURRENT : C U R R E N T;
CURRENT_DATE : C U R R E N T '_' D A T E;
CURRENT_DEFAULT_TRANSFORM_GROUP : C U R R E N T '_' D E F A U L T '_' T R A N S F O R M '_' G R O U P;
CURRENT_PATH : C U R R E N T '_' P A T H;
CURRENT_ROLE : C U R R E N T '_' R O L E;
CURRENT_TIME : C U R R E N T '_' T I M E;
CURRENT_TIMESTAMP : C U R R E N T '_' T I M E S T A M P;
CURRENT_TRANSFORM_GROUP_FOR_TYPE : C U R R E N T '_' T R A N S F O R M '_' G R O U P '_' F O R '_' T Y P E;
CURRENT_USER : C U R R E N T '_' U S E R;
CURSOR : C U R S O R;
CURSOR_NAME : C U R S O R '_' N A M E;
CYCLE : C Y C L E;
DATA : D A T A;
DATABASE : D A T A B A S E;
DATE : D A T E;
DATETIME_INTERVAL_CODE : D A T E T I M E '_' I N T E R V A L '_' C O D E;
DATETIME_INTERVAL_PRECISION : D A T E T I M E '_' I N T E R V A L '_' P R E C I S I O N;
DAY : D A Y;
DEALLOCATE : D E A L L O C A T E;
DEC : D E C;
DECIMAL : D E C I M A L;
DECLARE : D E C L A R E;
DEFAULT : D E F A U L T;
DEFAULTS : D E F A U L T S;
DEFERABLE : D E F E R A B L E;
DEFERRABLE : D E F E R R A B L E;
DEFERRED : D E F E R R E D;
DEFINED : D E F I N E D;
DEFINER : D E F I N E R;
DEGREE : D E G R E E;
DELETE : D E L E T E;
DELIMITER : D E L I M I T E R;
DELIMITERS : D E L I M I T E R S;
DENSE_RANK : D E N S E '_' R A N K;
DEPENDS : D E P E N D S;
DEPTH : D E P T H;
DEREF : D E R E F;
DERIVED : D E R I V E D;
DESC : D E S C;
DESCRIBE : D E S C R I B E;
DESCRIPTOR : D E S C R I P T O R;
DESTROY : D E S T R O Y;
DESTRUCTOR : D E S T R U C T O R;
DETERMINISTIC : D E T E R M I N I S T I C;
DIAGNOSTICS : D I A G N O S T I C S;
DICTIONARY : D I C T I O N A R Y;
DISABLE : D I S A B L E;
DISABLE_PAGE_SKIPPING : D I S A B L E '_' P A G E '_' S K I P P I N G;
DISCARD : D I S C A R D;
DISCONNECT : D I S C O N N E C T;
DISPATCH : D I S P A T C H;
DISTINCT : D I S T I N C T;
DO : D O;
DOMAIN : D O M A I N;
DOUBLE : D O U B L E;
DROP : D R O P;
DYNAMIC : D Y N A M I C;
DYNAMIC_FUNCTION : D Y N A M I C '_' F U N C T I O N;
DYNAMIC_FUNCTION_CODE : D Y N A M I C '_' F U N C T I O N '_' C O D E;
EACH : E A C H;
ELEMENT : E L E M E N T;
ELSE : E L S E;
ENABLE : E N A B L E;
ENCODING : E N C O D I N G;
ENCRYPTED : E N C R Y P T E D;
END : E N D;
END_EXEC : E N D '-' E X E C;
EQUALS : E Q U A L S;
ESCAPE : E S C A P E;
EVERY : E V E R Y;
EXCEPT : E X C E P T;
EXCEPTION : E X C E P T I O N;
EXCLUDE : E X C L U D E;
EXCLUDING : E X C L U D I N G;
EXCLUSIVE : E X C L U S I V E;
EXEC : E X E C;
EXECUTE : E X E C U T E;
EXISTING : E X I S T I N G;
EXISTS : E X I S T S;
EXP : E X P;
EXPLAIN : E X P L A I N;
EXTENDED : E X T E N D E D;
EXTENSION : E X T E N S I O N;
EXTERNAL : E X T E R N A L;
EXTRACT : E X T R A C T;
FALSE : F A L S E;
FETCH : F E T C H;
FIELDS : F I E L D S;
FILTER : F I L T E R;
FINAL : F I N A L;
FIRST : F I R S T;
FLOAT : F L O A T;
FLOOR : F L O O R;
FOLLOWING : F O L L O W I N G;
FOR : F O R;
FORCE : F O R C E;
FOREIGN : F O R E I G N;
FORMAT : F O R M A T;
FORTRAN : F O R T R A N;
FORWARD : F O R W A R D;
FOUND : F O U N D;
FREE : F R E E;
FREEZE : F R E E Z E;
FROM : F R O M;
FULL : F U L L;
FUNCTION : F U N C T I O N;
FUSION : F U S I O N;
G_ : G;
GENERAL : G E N E R A L;
GENERATED : G E N E R A T E D;
GET : G E T;
GLOBAL : G L O B A L;
GO : G O;
GOTO : G O T O;
GRANT : G R A N T;
GRANTED : G R A N T E D;
GREATEST : G R E A T E S T;
GROUP : G R O U P;
GROUPING : G R O U P I N G;
HANDLER : H A N D L E R;
HAVING : H A V I N G;
HIERARCHY : H I E R A R C H Y;
HOLD : H O L D;
HOST : H O S T;
HOUR : H O U R;
IDENTITY : I D E N T I T Y;
IGNORE : I G N O R E;
ILIKE : I L I K E;
IMMEDIATE : I M M E D I A T E;
IMMUTABLE : I M M U T A B L E;
IMPLEMENTATION : I M P L E M E N T A T I O N;
IMPLICIT : I M P L I C I T;
IN : I N;
INCLUDING : I N C L U D I N G;
INCREMENT : I N C R E M E N T;
INDEX : I N D E X;
INDICATOR : I N D I C A T O R;
INFIX : I N F I X;
INHERITS : I N H E R I T S;
INITIALIZE : I N I T I A L I Z E;
INITIALLY : I N I T I A L L Y;
INNER : I N N E R;
INOUT : I N O U T;
INPUT : I N P U T;
INSENSITIVE : I N S E N S I T I V E;
INSERT : I N S E R T;
INSTANCE : I N S T A N C E;
INSTANTIABLE : I N S T A N T I A B L E;
INSTEAD : I N S T E A D;
INT : I N T;
INTEGER : I N T E G E R;
INTERSECT : I N T E R S E C T;
INTERSECTION : I N T E R S E C T I O N;
INTERVAL : I N T E R V A L;
INTO : I N T O;
INVOKER : I N V O K E R;
IS : I S;
ISOLATION : I S O L A T I O N;
ITERATE : I T E R A T E;
JOIN : J O I N;
K_ : K;
KEY : K E Y;
KEY_MEMBER : K E Y '_' M E M B E R;
KEY_TYPE : K E Y '_' T Y P E;
LABEL : L A B E L;
LANCOMPILER : L A N C O M P I L E R;
LANGUAGE : L A N G U A G E;
LARGE : L A R G E;
LAST : L A S T;
LATERAL : L A T E R A L;
LEADING : L E A D I N G;
LEAST : L E A S T;
LEFT : L E F T;
LENGTH : L E N G T H;
LESS : L E S S;
LEVEL : L E V E L;
LIKE : L I K E;
LIMIT : L I M I T;
LISTEN : L I S T E N;
LN : L N;
LOAD : L O A D;
LOCAL : L O C A L;
LOCALTIME : L O C A L T I M E;
LOCALTIMESTAMP : L O C A L T I M E S T A M P;
LOCATION : L O C A T I O N;
LOCATOR : L O C A T O R;
LOCK : L O C K;
LOCKED : L O C K E D; // TODO: added manually, fix in docs
LOWER : L O W E R;
M_ : M;
MAIN : M A I N;
MAP : M A P;
MAPPING : M A P P I N G;
MATCH : M A T C H;
MATCH_SIMPLE : M A T C H '_' S I M P L E;
MATCHED : M A T C H E D;
MAX : M A X;
MAXVALUE : M A X V A L U E;
MEMBER : M E M B E R;
MERGE : M E R G E;
MESSAGE_LENGTH : M E S S A G E '_' L E N G T H;
MESSAGE_OCTET_LENGTH : M E S S A G E '_' O C T E T '_' L E N G T H;
MESSAGE_TEXT : M E S S A G E '_' T E X T;
METHOD : M E T H O D;
MIN : M I N;
MINUTE : M I N U T E;
MINVALUE : M I N V A L U E;
MOD : M O D;
MODE : M O D E;
MODIFIES : M O D I F I E S;
MODIFY : M O D I F Y;
MODULE : M O D U L E;
MONTH : M O N T H;
MORE_ : M O R E;
MOVE : M O V E;
MULTISET : M U L T I S E T;
MUMPS : M U M P S;
NAME : N A M E;
NAMES : N A M E S;
NATIONAL : N A T I O N A L;
NATURAL : N A T U R A L;
NCHAR : N C H A R;
NCLOB : N C L O B;
NESTING : N E S T I N G;
NEW : N E W;
NEXT : N E X T;
NO : N O;
NOCREATEDB : N O C R E A T E D B;
NOCREATEUSER : N O C R E A T E U S E R;
NONE : N O N E;
NORMALIZE : N O R M A L I Z E;
NORMALIZED : N O R M A L I Z E D;
NOT : N O T;
NOTHING : N O T H I N G;
NOTIFY : N O T I F Y;
NOTNULL : N O T N U L L;
NOWAIT : N O W A I T;
NULL : N U L L;
NULLABLE : N U L L A B L E;
NULLIF : N U L L I F;
NULLS : N U L L S;
NUMBER : N U M B E R;
NUMERIC : N U M E R I C;
OBJECT : O B J E C T;
OCTET_LENGTH : O C T E T '_' L E N G T H;
OCTETS : O C T E T S;
OF : O F;
OFF : O F F;
OFFSET : O F F S E T;
OIDS : O I D S;
OLD : O L D;
ON : O N;
ONLY : O N L Y;
OPEN : O P E N;
OPERATION : O P E R A T I O N;
OPERATOR : O P E R A T O R;
OPTION : O P T I O N;
OPTIONS : O P T I O N S;
OR : O R;
ORDER : O R D E R;
ORDERING : O R D E R I N G;
ORDINALITY : O R D I N A L I T Y;
OTHERS : O T H E R S;
OUT : O U T;
OUTER : O U T E R;
OUTPUT : O U T P U T;
OVER : O V E R;
OVERLAPS : O V E R L A P S;
OVERLAY : O V E R L A Y;
OVERRIDING : O V E R R I D I N G;
OWNER : O W N E R;
PAD : P A D;
PARAMETER : P A R A M E T E R;
PARAMETER_MODE : P A R A M E T E R '_' M O D E;
PARAMETER_NAME : P A R A M E T E R '_' N A M E;
PARAMETER_ORDINAL_POSITION : P A R A M E T E R '_' O R D I N A L '_' P O S I T I O N;
PARAMETER_SPECIFIC_CATALOG : P A R A M E T E R '_' S P E C I F I C '_' C A T A L O G;
PARAMETER_SPECIFIC_NAME : P A R A M E T E R '_' S P E C I F I C '_' N A M E;
PARAMETER_SPECIFIC_SCHEMA : P A R A M E T E R '_' S P E C I F I C '_' S C H E M A;
PARAMETERS : P A R A M E T E R S;
PARSER : P A R S E R;
PARTIAL : P A R T I A L;
PARTITION : P A R T I T I O N;
PASCAL : P A S C A L;
PASSWORD : P A S S W O R D;
PATH : P A T H;
PERCENT_RANK : P E R C E N T '_' R A N K;
PERCENTILE_CONT : P E R C E N T I L E '_' C O N T;
PERCENTILE_DISC : P E R C E N T I L E '_' D I S C;
PLACING : P L A C I N G;
PLAIN : P L A I N;
PLANS : P L A N S;
PLI : P L I;
POSITION : P O S I T I O N;
POSTFIX : P O S T F I X;
POWER : P O W E R;
PRECEDING : P R E C E D I N G;
PRECISION : P R E C I S I O N;
PREFIX : P R E F I X;
PREORDER : P R E O R D E R;
PREPARE : P R E P A R E;
PREPARED : P R E P A R E D;
PRESERVE : P R E S E R V E;
PRIMARY : P R I M A R Y;
PRIOR : P R I O R;
PRIVILEGES : P R I V I L E G E S;
PROCEDURAL : P R O C E D U R A L;
PROCEDURE : P R O C E D U R E;
PUBLIC : P U B L I C;
PUBLICATION : P U B L I C A T I O N;
QUOTE : Q U O T E;
RANGE : R A N G E;
RANK : R A N K;
READ : R E A D;
READS : R E A D S;
REAL : R E A L;
REASSIGN : R E A S S I G N;
RECHECK : R E C H E C K;
RECURSIVE : R E C U R S I V E;
REF : R E F;
REFERENCES : R E F E R E N C E S;
REFERENCING : R E F E R E N C I N G;
REFRESH : R E F R E S H;
REGR_AVGX : R E G R '_' A V G X;
REGR_AVGY : R E G R '_' A V G Y;
REGR_COUNT : R E G R '_' C O U N T;
REGR_INTERCEPT : R E G R '_' I N T E R C E P T;
REGR_R2 : R E G R '_' R '2';
REGR_SLOPE : R E G R '_' S L O P E;
REGR_SXX : R E G R '_' S X X;
REGR_SXY : R E G R '_' S X Y;
REGR_SYY : R E G R '_' S Y Y;
REINDEX : R E I N D E X;
RELATIVE : R E L A T I V E;
RELEASE : R E L E A S E;
RENAME : R E N A M E;
REPEATABLE : R E P E A T A B L E;
REPLACE : R E P L A C E;
REPLICA : R E P L I C A;
RESET : R E S E T;
RESTART : R E S T A R T;
RESTRICT : R E S T R I C T;
RESULT : R E S U L T;
RETURN : R E T U R N;
RETURNED_CARDINALITY : R E T U R N E D '_' C A R D I N A L I T Y;
RETURNED_LENGTH : R E T U R N E D '_' L E N G T H;
RETURNED_OCTET_LENGTH : R E T U R N E D '_' O C T E T '_' L E N G T H;
RETURNED_SQLSTATE : R E T U R N E D '_' S Q L S T A T E;
RETURNING : R E T U R N I N G;
RETURNS : R E T U R N S;
REVOKE : R E V O K E;
RIGHT : R I G H T;
ROLE : R O L E;
ROLLBACK : R O L L B A C K;
ROLLUP : R O L L U P;
ROUTINE : R O U T I N E;
ROUTINE_CATALOG : R O U T I N E '_' C A T A L O G;
ROUTINE_NAME : R O U T I N E '_' N A M E;
ROUTINE_SCHEMA : R O U T I N E '_' S C H E M A;
ROW : R O W;
ROW_COUNT : R O W '_' C O U N T;
ROW_NUMBER : R O W '_' N U M B E R;
ROWS : R O W S;
RULE : R U L E;
SAVEPOINT : S A V E P O I N T;
SCALE : S C A L E;
SCHEMA : S C H E M A;
SCHEMA_NAME : S C H E M A '_' N A M E;
SCOPE : S C O P E;
SCOPE_CATALOG : S C O P E '_' C A T A L O G;
SCOPE_NAME : S C O P E '_' N A M E;
SCOPE_SCHEMA : S C O P E '_' S C H E M A;
SCROLL : S C R O L L;
SEARCH : S E A R C H;
SECOND : S E C O N D;
SECTION : S E C T I O N;
SECURITY : S E C U R I T Y;
SELECT : S E L E C T;
SELF : S E L F;
SENSITIVE : S E N S I T I V E;
SEQUENCE : S E Q U E N C E;
SEQUENCES : S E Q U E N C E S;
SERIALIZABLE : S E R I A L I Z A B L E;
SERVER_NAME : S E R V E R '_' N A M E;
SESSION : S E S S I O N;
SESSION_USER : S E S S I O N '_' U S E R;
SET : S E T;
SETOF : S E T O F;
SETS : S E T S;
SHARE : S H A R E;
SHOW : S H O W;
SIMILAR : S I M I L A R;
SIMPLE : S I M P L E;
SIZE : S I Z E;
SKIP_ : S K I P; // TODO: added manually, fix in docs
SMALLINT : S M A L L I N T;
SNAPSHOT : S N A P S H O T;
SOME : S O M E;
SOURCE : S O U R C E;
SPACE : S P A C E;
SPECIFIC : S P E C I F I C;
SPECIFIC_NAME : S P E C I F I C '_' N A M E;
SPECIFICTYPE : S P E C I F I C T Y P E;
SQL : S Q L;
SQLCODE : S Q L C O D E;
SQLERROR : S Q L E R R O R;
SQLEXCEPTION : S Q L E X C E P T I O N;
SQLSTATE : S Q L S T A T E;
SQLWARNING : S Q L W A R N I N G;
SQRT : S Q R T;
STABLE : S T A B L E;
START : S T A R T;
STATE : S T A T E;
STATEMENT : S T A T E M E N T;
STATIC : S T A T I C;
STATISTICS : S T A T I S T I C S;
STDDEV_POP : S T D D E V '_' P O P;
STDDEV_SAMP : S T D D E V '_' S A M P;
STDIN : S T D I N;
STDOUT : S T D O U T;
STORAGE : S T O R A G E;
STRICT : S T R I C T;
STRUCTURE : S T R U C T U R E;
STYLE : S T Y L E;
SUBCLASS_ORIGIN : S U B C L A S S '_' O R I G I N;
SUBLIST : S U B L I S T;
SUBMULTISET : S U B M U L T I S E T;
SUBSCRIPTION : S U B S C R I P T I O N;
SUBSTRING : S U B S T R I N G;
SUM : S U M;
SYMMETRIC : S Y M M E T R I C;
SYSID : S Y S I D;
SYSTEM : S Y S T E M;
SYSTEM_USER : S Y S T E M '_' U S E R;
TABLE : T A B L E;
TABLE_NAME : T A B L E '_' N A M E;
TABLESAMPLE : T A B L E S A M P L E;
TABLESPACE : T A B L E S P A C E;
TEMP : T E M P;
TEMPLATE : T E M P L A T E;
TEMPORARY : T E M P O R A R Y;
TERMINATE : T E R M I N A T E;
THAN : T H A N;
THEN : T H E N;
TIES : T I E S;
TIME : T I M E;
TIMESTAMP : T I M E S T A M P;
TIMEZONE_HOUR : T I M E Z O N E '_' H O U R;
TIMEZONE_MINUTE : T I M E Z O N E '_' M I N U T E;
TIMING : T I M I N G;
TO : T O;
TOAST : T O A S T;
TOP_LEVEL_COUNT : T O P '_' L E V E L '_' C O U N T;
TRAILING : T R A I L I N G;
TRANSACTION : T R A N S A C T I O N;
TRANSACTION_ACTIVE : T R A N S A C T I O N '_' A C T I V E;
TRANSACTIONS_COMMITTED : T R A N S A C T I O N S '_' C O M M I T T E D;
TRANSACTIONS_ROLLED_BACK : T R A N S A C T I O N S '_' R O L L E D '_' B A C K;
TRANSFORM : T R A N S F O R M;
TRANSFORMS : T R A N S F O R M S;
TRANSLATE : T R A N S L A T E;
TRANSLATION : T R A N S L A T I O N;
TREAT : T R E A T;
TRIGGER : T R I G G E R;
TRIGGER_CATALOG : T R I G G E R '_' C A T A L O G;
TRIGGER_NAME : T R I G G E R '_' N A M E;
TRIGGER_SCHEMA : T R I G G E R '_' S C H E M A;
TRIM : T R I M;
TRUE : T R U E;
TRUNCATE : T R U N C A T E;
TRUSTED : T R U S T E D;
TYPE : T Y P E;
UESCAPE : U E S C A P E;
UNBOUNDED : U N B O U N D E D;
UNCOMMITTED : U N C O M M I T T E D;
UNDER : U N D E R;
UNENCRYPTED : U N E N C R Y P T E D;
UNION : U N I O N;
UNIQUE : U N I Q U E;
UNKNOWN : U N K N O W N;
UNLISTEN : U N L I S T E N;
UNLOGGED : U N L O G G E D;
UNNAMED : U N N A M E D;
UNNEST : U N N E S T;
UNTIL : U N T I L;
UPDATE : U P D A T E;
UPPER : U P P E R;
USAGE : U S A G E;
USER : U S E R;
USER_DEFINED_TYPE_CATALOG : U S E R '_' D E F I N E D '_' T Y P E '_' C A T A L O G;
USER_DEFINED_TYPE_CODE : U S E R '_' D E F I N E D '_' T Y P E '_' C O D E;
USER_DEFINED_TYPE_NAME : U S E R '_' D E F I N E D '_' T Y P E '_' N A M E;
USER_DEFINED_TYPE_SCHEMA : U S E R '_' D E F I N E D '_' T Y P E '_' S C H E M A;
USING : U S I N G;
VACUUM : V A C U U M;
VALID : V A L I D;
VALIDATE : V A L I D A T E;
VALIDATOR : V A L I D A T O R;
VALUE : V A L U E;
VALUES : V A L U E S;
VAR_POP : V A R '_' P O P;
VAR_SAMP : V A R '_' S A M P;
VARCHAR : V A R C H A R;
VARIABLE : V A R I A B L E;
VARIADIC : V A R I A D I C; // TODO: added manually, fix in docs
VARYING : V A R Y I N G;
VERBOSE : V E R B O S E;
VIEW : V I E W;
VOLATILE : V O L A T I L E;
WHEN : W H E N;
WHENEVER : W H E N E V E R;
WHERE : W H E R E;
WIDTH_BUCKET : W I D T H '_' B U C K E T;
WINDOW : W I N D O W;
WITH : W I T H;
WITHIN : W I T H I N;
WITHOUT : W I T H O U T;
WORK : W O R K;
WRITE : W R I T E;
YAML : Y A M L;
YEAR : Y E A R;
YES : Y E S;
ZONE : Z O N E;
// role options
SUPERUSER : S U P E R U S E R;
NOSUPERUSER : N O S U P E R U S E R;
CREATEROLE : C R E A T E R O L E;
NOCREATEROLE : N O C R E A T E R O L E;
INHERIT : I N H E R I T;
NOINHERIT : N O I N H E R I T;
LOGIN : L O G I N;
NOLOGIN : N O L O G I N;
REPLICATION : R E P L I C A T I O N;
NOREPLICATION : N O R E P L I C A T I O N;
BYPASSRLS : B Y P A S S R L S;
NOBYPASSRLS : N O B Y P A S S R L S;
// create aggregate options
SFUNC : S F U N C;
STYPE : S T Y P E;
SSPACE : S S P A C E;
FINALFUNC : F I N A L F U N C;
FINALFUNC_EXTRA : F I N A L F U N C '_' E X T R A;
COMBINEFUNC : C O M B I N E F U N C;
SERIALFUNC : S E R I A L F U N C;
DESERIALFUNC : D E S E R I A L F U N C;
INITCOND : I N I T C O N D;
MSFUNC : M S F U N C;
MINVFUNC : M I N V F U N C;
MSTYPE : M S T Y P E;
MSSPACE : M S S P A C E;
MFINALFUNC : M F I N A L F U N C;
MFINALFUNC_EXTRA : M F I N A L F U N C '_' E X T R A;
MINITCOND : M I N I T C O N D;
SORTOP : S O R T O P;
PARALLEL : P A R A L L E L;
HYPOTHETICAL : H Y P O T H E T I C A L;
SAFE : S A F E;
RESTRICTED : R E S T R I C T E D;
UNSAFE : U N S A F E;
BASETYPE : B A S E T Y P E;
// create collation
IF : I F;
// create collation options
LOCALE : L O C A L E;
LC_COLLATE : L C '_' C O L L A T E;
LC_CTYPE : L C '_' C T Y P E;
PROVIDER : P R O V I D E R;
VERSION : V E R S I O N;
// create database fields
ALLOW_CONNECTIONS : A L L O W '_' C O N N E C T I O N S ;
IS_TEMPLATE : I S '_' T E M P L A T E ;
// create event
EVENT : E V E N T;
// create foreign data wrapper
WRAPPER : W R A P P E R;
// create foreign table
SERVER : S E R V E R;
// create index
BTREE : B T R E E;
HASH_ : H A S H;
GIST : G I S T;
SPGIST : S P G I S T;
GIN : G I N;
BRIN : B R I N;
CONCURRENTLY : C O N C U R R E N T L Y;
// create language
INLINE : I N L I N E;
// create materialized view
MATERIALIZED : M A T E R I A L I Z E D;
// create operator
LEFTARG : L E F T A R G;
RIGHTARG : R I G H T A R G;
COMMUTATOR : C O M M U T A T O R;
NEGATOR : N E G A T O R;
HASHES : H A S H E S;
MERGES : M E R G E S;
// create operator family
FAMILY : F A M I L Y;
// create policy
POLICY : P O L I C Y;
// create sequence
OWNED : O W N E D;
// builtin types that are not reserved keywords that are used in prefix type casts (i.e. {type} {expr})
ABSTIME : A B S T I M E;
BIGSERIAL : B I G S E R I A L;
BIT_VARYING : B I T ' ' V A R Y I N G;
BOOL : B O O L;
BOX : B O X;
BYTEA : B Y T E A;
CHARACTER_VARYING : C H A R A C T E R ' ' V A R Y I N G;
CIDR : C I D R;
CIRCLE : C I R C L E;
FLOAT4 : F L O A T '4';
FLOAT8 : F L O A T '8';
INET : I N E T;
INT2 : I N T '2';
INT4 : I N T '4';
INT8 : I N T '8';
JSON : J S O N;
JSONB : J S O N B;
LINE : L I N E;
LSEG : L S E G;
MACADDR : M A C A D D R;
MACADDR8 : M A C A D D R '8';
MONEY : M O N E Y;
PG_LSN : P G '_' L S N;
POINT : P O I N T;
POLYGON : P O L Y G O N;
RELTIME : R E L T I M E;
SERIAL : S E R I A L;
SERIAL2 : S E R I A L '2';
SERIAL4 : S E R I A L '4';
SERIAL8 : S E R I A L '8';
SMALLSERIAL : S M A L L S E R I A L;
STSTEM : S T S T E M;
TEXT : T E X T;
TIMESTAMPTZ : T I M E S T A M P T Z;
TIMETZ : T I M E T Z;
TSQUERY : T S Q U E R Y;
TSVECTOR : T S V E C T O R;
TXID_SNAPSHOT : T X I D '_' S N A P S H O T;
UUID : U U I D;
VARBIT : V A R B I T;
XML : X M L;
// language tokens
COMMA : ',';
COLON : ':';
COLON_COLON : '::';
DOLLAR : '$';
DOLLAR_DOLLAR : '$$';
STAR : '*';
OPEN_PAREN : '(';
CLOSE_PAREN : ')';
OPEN_BRACKET : '[';
CLOSE_BRACKET : ']';
BIT_STRING : B '\'' ('0'|'1')* '\'';
REGEX_STRING : E SQUOTA_STRING;
NUMERIC_LITERAL : '-'? DEC_DIGIT+ '.' DEC_DIGIT+ (E ('-')* DEC_DIGIT+)?;
INTEGER_LITERAL : '-'? DEC_DIGIT+ (E DEC_DIGIT+)?;
HEX_INTEGER_LITERAL : 'x' SQUOTA_STRING;
DOT : '.';
SINGLEQ_STRING_LITERAL : SQUOTA_STRING;
DOUBLEQ_STRING_LITERAL : DQUOTA_STRING;
IDENTIFIER : [a-zA-Z_][a-zA-Z_0-9$]*;
DOLLAR_DEC : '$' DEC_DIGIT+;
IDENTIFIER_UNICODE : [a-zA-Z_\u00A1-\uFFFF][a-zA-Z_\u00A1-\uFFFF0-9$]*;
// operator tokens
AMP : '&';
AMP_AMP : '&&';
AMP_LT : '&<';
AT_AT : '@@';
AT_GT : '@>';
AT_SIGN : '@';
BANG : '!';
BANG_BANG : '!!';
BANG_EQUAL : '!=';
CARET : '^';
EQUAL : '=';
EQUAL_GT : '=>';
GT : '>';
GTE : '>=';
GT_GT : '>>';
HASH : '#';
HASH_EQ : '#=';
HASH_GT : '#>';
HASH_GT_GT : '#>>';
HASH_HASH : '##';
HYPHEN_GT : '->';
HYPHEN_GT_GT : '->>';
HYPHEN_PIPE_HYPHEN : '-|-';
LT : '<';
LTE : '<=';
LT_AT : '<@';
LT_CARET : '<^';
LT_GT : '<>';
LT_HYPHEN_GT : '<->';
LT_LT : '<<';
LT_LT_EQ : '<<=';
LT_QMARK_GT : '<?>';
MINUS : '-';
PERCENT : '%';
PIPE : '|';
PIPE_PIPE : '||';
PIPE_PIPE_SLASH : '||/';
PIPE_SLASH : '|/';
PLUS : '+';
QMARK : '?';
QMARK_AMP : '?&';
QMARK_HASH : '?#';
QMARK_HYPHEN : '?-';
QMARK_PIPE : '?|';
SLASH : '/';
TIL : '~';
TIL_EQ : '~=';
TIL_GTE_TIL : '~>=~';
TIL_GT_TIL : '~>~';
TIL_LTE_TIL : '~<=~';
TIL_LT_TIL : '~<~';
TIL_STAR : '~*';
TIL_TIL : '~~';
SEMI: ';';
SPEL : '#{' ANYTHING '}';
fragment ANYTHING : (.)*?;

1907
headless-services/commons/jpql/grammars/PostgreSqlParser.g4 Normal file
View File

File diff suppressed because it is too large Load Diff

6214
headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.java Normal file
View File

File diff suppressed because it is too large Load Diff

50547
headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.java Normal file
View File

File diff suppressed because it is too large Load Diff

3232
headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBaseListener.java Normal file
View File

File diff suppressed because it is too large Load Diff

2670
headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserListener.java Normal file
View File

File diff suppressed because it is too large Load Diff

46
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokens.java
View File

@@ -11,17 +11,25 @@
package org.springframework.ide.vscode.boot.java.data.jpa.queries;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import org.antlr.v4.runtime.ANTLRErrorListener;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.ConsoleErrorListener;
import org.antlr.v4.runtime.Parser;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.atn.ATNConfigSet;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens;
@@ -40,13 +48,19 @@ public class HqlSemanticTokens implements SemanticTokensDataProvider {
private static List<String> TOKEN_TYPES = List.of("keyword", "type", "class", "string", "number", "operator",
"variable", "method", "parameter");
private Optional<SpelSemanticTokens> optSpelTokens;
private final Optional<SpelSemanticTokens> optSpelTokens;
private final Optional<Consumer<RecognitionException>> parseErrorHandler;
public HqlSemanticTokens(Optional<SpelSemanticTokens> optSpelTokens) {
this.optSpelTokens = optSpelTokens;
this(optSpelTokens, Optional.empty());
}
public HqlSemanticTokens(Optional<SpelSemanticTokens> optSpelTokens, Optional<Consumer<RecognitionException>> parseErrorHandler) {
this.optSpelTokens = optSpelTokens;
this.parseErrorHandler = parseErrorHandler;
}
@Override
public List<String> getTokenTypes() {
LinkedHashSet<String> tokenTypes = new LinkedHashSet<>(TOKEN_TYPES);
@@ -136,6 +150,30 @@ public class HqlSemanticTokens implements SemanticTokensDataProvider {
});
parser.addErrorListener(new ANTLRErrorListener() {
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine,
String msg, RecognitionException e) {
parseErrorHandler.ifPresent(h -> h.accept(e));
}
@Override
public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction,
ATNConfigSet configs) {
}
@Override
public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex,
BitSet conflictingAlts, ATNConfigSet configs) {
}
@Override
public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact,
BitSet ambigAlts, ATNConfigSet configs) {
}
});
parser.ql_statement();
semantics.entrySet().stream()

6
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java
View File

@@ -56,6 +56,7 @@ public class JdtDataQuerySemanticTokensProvider implements JdtSemanticTokensProv
this.sqlTokenProviders = new LinkedHashMap<>();
this.sqlTokenProviders.put(SqlType.MYSQL, new MySqlSemanticTokens(spelSemanticTokens));
this.sqlTokenProviders.put(SqlType.POSTGRESQL, new PostgreSqlSemanticTokens(spelSemanticTokens));
}
@Override
@@ -169,6 +170,11 @@ public class JdtDataQuerySemanticTokensProvider implements JdtSemanticTokensProv
}
private SemanticTokensDataProvider getSqlSemanticTokensProvider(IJavaProject project) {
if (SpringProjectUtil.hasDependencyStartingWith(project, "mysql-connector", null)) {
return sqlTokenProviders.get(SqlType.MYSQL);
} else if (SpringProjectUtil.hasDependencyStartingWith(project, "postgresql", null)) {
return sqlTokenProviders.get(SqlType.POSTGRESQL);
}
return sqlTokenProviders.get(SqlType.MYSQL);
}

49
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokens.java
View File

@@ -11,17 +11,25 @@
package org.springframework.ide.vscode.boot.java.data.jpa.queries;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import org.antlr.v4.runtime.ANTLRErrorListener;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.ConsoleErrorListener;
import org.antlr.v4.runtime.Parser;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.atn.ATNConfigSet;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens;
@@ -43,22 +51,29 @@ public class JpqlSemanticTokens implements SemanticTokensDataProvider {
private static List<String> TOKEN_TYPES = List.of("keyword", "type", "class", "string", "number", "operator",
"variable", "method", "regexp", "parameter");
final private Optional<SpelSemanticTokens> optSpelSemantictokens;
private final Optional<SpelSemanticTokens> optSpelTokens;
private final Optional<Consumer<RecognitionException>> parseErrorHandler;
public JpqlSemanticTokens(Optional<SpelSemanticTokens> optSpelSemantictokens) {
this.optSpelSemantictokens = optSpelSemantictokens;
this(optSpelSemantictokens, Optional.empty());
}
public JpqlSemanticTokens(Optional<SpelSemanticTokens> optSpelTokens, Optional<Consumer<RecognitionException>> parseErrorHandler) {
this.optSpelTokens = optSpelTokens;
this.parseErrorHandler = parseErrorHandler;
}
@Override
public List<String> getTokenTypes() {
LinkedHashSet<String> tokenTypes = new LinkedHashSet<>(TOKEN_TYPES);
tokenTypes.addAll(optSpelSemantictokens.map(s -> s.getTokenTypes()).orElse(Collections.emptyList()));
tokenTypes.addAll(optSpelTokens.map(s -> s.getTokenTypes()).orElse(Collections.emptyList()));
return tokenTypes.stream().toList();
}
@Override
public List<String> getTypeModifiers() {
return optSpelSemantictokens.map(s -> s.getTypeModifiers()).orElse(Collections.emptyList());
return optSpelTokens.map(s -> s.getTypeModifiers()).orElse(Collections.emptyList());
}
@Override
@@ -99,7 +114,7 @@ public class JpqlSemanticTokens implements SemanticTokensDataProvider {
case JpqlParser.WS:
break;
case JpqlParser.SPEL:
tokens.addAll(computeTokensFromSpelNode(node, initialOffset, optSpelSemantictokens));
tokens.addAll(computeTokensFromSpelNode(node, initialOffset, optSpelTokens));
break;
default:
if (JpqlParser.WS < type && type <= JpqlParser.WHERE) {
@@ -156,6 +171,30 @@ public class JpqlSemanticTokens implements SemanticTokensDataProvider {
});
parser.addErrorListener(new ANTLRErrorListener() {
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine,
String msg, RecognitionException e) {
parseErrorHandler.ifPresent(h -> h.accept(e));
}
@Override
public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction,
ATNConfigSet configs) {
}
@Override
public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex,
BitSet conflictingAlts, ATNConfigSet configs) {
}
@Override
public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact,
BitSet ambigAlts, ATNConfigSet configs) {
}
});
parser.ql_statement();
semantics.entrySet().stream()

104
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokens.java
View File

@@ -11,19 +11,27 @@
package org.springframework.ide.vscode.boot.java.data.jpa.queries;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.Stream;
import org.antlr.v4.runtime.ANTLRErrorListener;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.ConsoleErrorListener;
import org.antlr.v4.runtime.Parser;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.atn.ATNConfigSet;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens;
@@ -32,19 +40,26 @@ import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.Sem
import org.springframework.ide.vscode.parser.mysql.MySqlLexer;
import org.springframework.ide.vscode.parser.mysql.MySqlParser;
import org.springframework.ide.vscode.parser.mysql.MySqlParser.ParameterContext;
import org.springframework.ide.vscode.parser.mysql.MySqlParser.UdfFunctionCallContext;
import org.springframework.ide.vscode.parser.mysql.MySqlParserBaseListener;
public class MySqlSemanticTokens implements SemanticTokensDataProvider {
private static List<String> TOKEN_TYPES = List.of("keyword", "type", "string", "number", "operator",
"variable", "regexp", "comment", "parameter");
"variable", "regexp", "comment", "parameter", "method");
private Optional<SpelSemanticTokens> optSpelTokens;
private final Optional<SpelSemanticTokens> optSpelTokens;
private final Optional<Consumer<RecognitionException>> parseErrorHandler;
public MySqlSemanticTokens(Optional<SpelSemanticTokens> optSpelTokens) {
this.optSpelTokens = optSpelTokens;
this(optSpelTokens, Optional.empty());
}
public MySqlSemanticTokens(Optional<SpelSemanticTokens> optSpelTokens, Optional<Consumer<RecognitionException>> parseErrorHandler) {
this.optSpelTokens = optSpelTokens;
this.parseErrorHandler = parseErrorHandler;
}
@Override
public List<String> getTokenTypes() {
LinkedHashSet<String> tokenTypes = new LinkedHashSet<>(TOKEN_TYPES);
@@ -82,7 +97,7 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider {
semantics.put(node.getSymbol(), "variable");
break;
case MySqlParser.DOT_ID:
semantics.put(node.getSymbol(), "variable");
semantics.put(node.getSymbol(), "property");
break;
case MySqlParser.DOT:
semantics.put(node.getSymbol(), "operator");
@@ -116,7 +131,7 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider {
semantics.put(node.getSymbol(), "comment");
break;
default:
if (MySqlParser.VAR_ASSIGN <= type && type <= MySqlParser.COLON_SYMB) {
if (MySqlParser.VAR_ASSIGN <= type && type <= MySqlParser.QUESTION_SYMB) {
semantics.put(node.getSymbol(), "operator");
} else if (MySqlParser.DECIMAL_LITERAL <= type && type <= MySqlParser.BIT_STRING) {
semantics.put(node.getSymbol(), "number");
@@ -180,6 +195,18 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider {
public void visitErrorNode(ErrorNode node) {
processTerminalNode(node);
}
@Override
public void exitUdfFunctionCall(UdfFunctionCallContext fc) {
if (fc.fullId() != null) {
List<Token> ls = getAllLeafs(fc.fullId()).toList();
if (!ls.isEmpty()) {
semantics.put(ls.get(ls.size() - 1), "method");
}
}
}
@Override
public void exitParameter(ParameterContext ctx) {
@@ -194,25 +221,55 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider {
}
}
private Stream<Token> getAllLeafs(ParserRuleContext ctx) {
return ctx.children.stream().flatMap(n -> {
if (n instanceof ParserRuleContext prc) {
return getAllLeafs(prc);
} else if (n instanceof TerminalNode tn) {
return Stream.of(tn.getSymbol());
}
return Stream.empty();
});
});
parser.addErrorListener(new ANTLRErrorListener() {
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine,
String msg, RecognitionException e) {
parseErrorHandler.ifPresent(h -> h.accept(e));
}
@Override
public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction,
ATNConfigSet configs) {
}
@Override
public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex,
BitSet conflictingAlts, ATNConfigSet configs) {
}
@Override
public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact,
BitSet ambigAlts, ATNConfigSet configs) {
}
});
parser.sqlStatements();
semantics.entrySet().stream()
.map(e -> new SemanticTokenData(e.getKey().getStartIndex() + initialOffset,
e.getKey().getStartIndex() + e.getKey().getText().length() + initialOffset, e.getValue(),
new String[0]))
.flatMap(e -> {
int startIndex = e.getKey().getStartIndex();
if (e.getKey().getType() == MySqlLexer.DOT_ID) {
return Stream.of(
// the prefix '.' is an operator
new SemanticTokenData(startIndex + initialOffset,
startIndex + 1 + initialOffset, "operator",
new String[0]),
// the rest whatever it was meant to be initially
new SemanticTokenData(startIndex + 1 + initialOffset,
startIndex + e.getKey().getText().length() + initialOffset, e.getValue(),
new String[0])
);
} else {
return Stream.of(new SemanticTokenData(startIndex + initialOffset,
startIndex + e.getKey().getText().length() + initialOffset, e.getValue(),
new String[0]));
}
})
.forEach(tokens::add);
Collections.sort(tokens);
@@ -220,5 +277,18 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider {
return tokens;
}
static Stream<Token> getAllLeafs(ParserRuleContext ctx) {
return ctx.children.stream().flatMap(n -> {
if (n instanceof ParserRuleContext prc) {
return getAllLeafs(prc);
} else if (n instanceof TerminalNode tn) {
return Stream.of(tn.getSymbol());
}
return Stream.empty();
});
}
}

204
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokens.java Normal file
View File

@@ -0,0 +1,204 @@
/*******************************************************************************
* Copyright (c) 2024 Broadcom, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Broadcom, Inc. - initial API and implementation
*******************************************************************************/
package org.springframework.ide.vscode.boot.java.data.jpa.queries;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import org.antlr.v4.runtime.ANTLRErrorListener;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.ConsoleErrorListener;
import org.antlr.v4.runtime.Parser;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.atn.ATNConfigSet;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens;
import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.SemanticTokenData;
import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.SemanticTokensDataProvider;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlLexer;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.Data_typeContext;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.Func_nameContext;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.IdentifierContext;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.ParameterContext;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParserBaseListener;
public class PostgreSqlSemanticTokens implements SemanticTokensDataProvider {
private static List<String> TOKEN_TYPES = List.of("keyword", "type", "string", "number", "operator",
"variable", "regexp", "comment", "parameter", "method");
private Optional<SpelSemanticTokens> optSpelTokens;
private Optional<Consumer<RecognitionException>> parseErrorHandler;
public PostgreSqlSemanticTokens(Optional<SpelSemanticTokens> optSpelTokens) {
this(optSpelTokens, Optional.empty());
}
public PostgreSqlSemanticTokens(Optional<SpelSemanticTokens> optSpelTokens, Optional<Consumer<RecognitionException>> parseErrorHandler) {
this.optSpelTokens = optSpelTokens;
this.parseErrorHandler = parseErrorHandler;
}
@Override
public List<String> getTokenTypes() {
LinkedHashSet<String> tokenTypes = new LinkedHashSet<>(TOKEN_TYPES);
tokenTypes.addAll(optSpelTokens.map(s -> s.getTokenTypes()).orElse(Collections.emptyList()));
return tokenTypes.stream().toList();
}
@Override
public List<String> getTypeModifiers() {
return optSpelTokens.map(s -> s.getTypeModifiers()).orElse(Collections.emptyList());
}
@Override
public List<SemanticTokenData> computeTokens(String text, int initialOffset) {
PostgreSqlLexer lexer = new PostgreSqlLexer(CharStreams.fromString(text));
CommonTokenStream antlrTokens = new CommonTokenStream(lexer);
PostgreSqlParser parser = new PostgreSqlParser(antlrTokens);
Map<Token, String> semantics = new HashMap<>();
List<SemanticTokenData> tokens = new ArrayList<>();
lexer.removeErrorListener(ConsoleErrorListener.INSTANCE);
parser.removeErrorListener(ConsoleErrorListener.INSTANCE);
parser.addParseListener(new PostgreSqlParserBaseListener() {
private void processTerminalNode(TerminalNode node) {
Token token = node.getSymbol();
int type = token.getType();
if (type >= PostgreSqlLexer.A_ && type <= PostgreSqlLexer.OWNED) {
semantics.put(token, "keyword");
} else if (type >= PostgreSqlLexer.ABSTIME && type <= PostgreSqlLexer.XML) {
semantics.put(token, "type");
} else if ((type >= PostgreSqlLexer.AMP && type <= PostgreSqlLexer.SEMI)
|| (type >= PostgreSqlLexer.COMMA && type <= PostgreSqlLexer.CLOSE_BRACKET)
|| type == PostgreSqlLexer.DOT) {
semantics.put(token, "operator");
} else if (type == PostgreSqlLexer.REGEX_STRING) {
semantics.put(token, "regexp");
} else if (type >= PostgreSqlLexer.SINGLEQ_STRING_LITERAL && type <= PostgreSqlLexer.DOUBLEQ_STRING_LITERAL) {
semantics.put(token, "string");
} else if ((type >= PostgreSqlLexer.NUMERIC_LITERAL && type <= PostgreSqlLexer.HEX_INTEGER_LITERAL)
|| type == PostgreSqlLexer.DOLLAR_DEC || type == PostgreSqlLexer.BIT_STRING) {
semantics.put(token, "number");
} else if (type == PostgreSqlLexer.IDENTIFIER) {
semantics.put(token, "variable");
} else if (type >= PostgreSqlLexer.BLOCK_COMMENT && type <= PostgreSqlLexer.LINE_COMMENT) {
semantics.put(token, "comment");
} else if (type == PostgreSqlLexer.SPEL) {
tokens.addAll(JpqlSemanticTokens.computeTokensFromSpelNode(node, initialOffset, optSpelTokens));
}
}
@Override
public void visitTerminal(TerminalNode node) {
processTerminalNode(node);
}
@Override
public void visitErrorNode(ErrorNode node) {
processTerminalNode(node);
}
@Override
public void exitIdentifier(IdentifierContext ctx) {
if (ctx.identifier() != null) {
for (int i = 1; i < ctx.identifier().size(); i++) {
IdentifierContext identifier = ctx.identifier(i);
if (identifier.IDENTIFIER() != null) {
semantics.put(identifier.IDENTIFIER().getSymbol(), "property");
}
}
}
}
@Override
public void exitFunc_name(Func_nameContext funcName) {
if (funcName.identifier() != null && funcName.identifier().IDENTIFIER() != null) {
semantics.put(funcName.identifier().IDENTIFIER().getSymbol(), "method");
}
}
@Override
public void exitData_type(Data_typeContext dataType) {
if (dataType.identifier() != null) {
MySqlSemanticTokens.getAllLeafs(dataType.identifier())
.filter(t -> t.getType() == PostgreSqlLexer.IDENTIFIER)
.forEach(t -> semantics.put(t, "type"));
}
}
@Override
public void exitParameter(ParameterContext param) {
if (param.identifier() != null) {
MySqlSemanticTokens.getAllLeafs(param.identifier()).forEach(t -> semantics.put(t, "parameter"));
}
if (param.INTEGER_LITERAL() != null) {
semantics.put(param.INTEGER_LITERAL().getSymbol(), "parameter");
}
}
});
parser.addErrorListener(new ANTLRErrorListener() {
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine,
String msg, RecognitionException e) {
parseErrorHandler.ifPresent(h -> h.accept(e));
}
@Override
public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction,
ATNConfigSet configs) {
}
@Override
public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex,
BitSet conflictingAlts, ATNConfigSet configs) {
}
@Override
public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact,
BitSet ambigAlts, ATNConfigSet configs) {
}
});
parser.root();
semantics.entrySet().stream()
.map(e -> new SemanticTokenData(e.getKey().getStartIndex() + initialOffset,
e.getKey().getStartIndex() + e.getKey().getText().length() + initialOffset, e.getValue(),
new String[0]))
.forEach(tokens::add);
Collections.sort(tokens);
return tokens;
}
}

5
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java
View File

@@ -38,6 +38,8 @@ import org.springframework.ide.vscode.commons.languageserver.reconcile.IProblemC
import org.springframework.ide.vscode.commons.languageserver.reconcile.ProblemType;
import org.springframework.ide.vscode.parser.mysql.MySqlLexer;
import org.springframework.ide.vscode.parser.mysql.MySqlParser;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlLexer;
import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser;
public class QueryJdtAstReconciler implements JdtAstReconciler {
@@ -53,6 +55,7 @@ public class QueryJdtAstReconciler implements JdtAstReconciler {
this.sqlReconcilers = new LinkedHashMap<>();
this.sqlReconcilers.put(SqlType.MYSQL, new AntlrReconcilerWithSpel("MySQL", MySqlParser.class, MySqlLexer.class, "sqlStatements", QueryProblemType.SQL_SYNTAX, spelReconciler, MySqlLexer.SPEL));
this.sqlReconcilers.put(SqlType.POSTGRESQL, new AntlrReconcilerWithSpel("PostgreSQL", PostgreSqlParser.class, PostgreSqlLexer.class, "root", QueryProblemType.SQL_SYNTAX, spelReconciler, PostgreSqlLexer.SPEL));
}
@Override
@@ -169,6 +172,8 @@ public class QueryJdtAstReconciler implements JdtAstReconciler {
private Optional<Reconciler> getSqlReconciler(IJavaProject project) {
if (SpringProjectUtil.hasDependencyStartingWith(project, "mysql-connector", null)) {
return Optional.of(sqlReconcilers.get(SqlType.MYSQL));
} else if (SpringProjectUtil.hasDependencyStartingWith(project, "postgresql", null)) {
return Optional.of(sqlReconcilers.get(SqlType.POSTGRESQL));
}
return Optional.empty();
}

3
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlType.java
View File

@@ -12,6 +12,7 @@ package org.springframework.ide.vscode.boot.java.data.jpa.queries;
public enum SqlType {
MYSQL
MYSQL,
POSTGRESQL
}

3
headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokensTest.java
View File

@@ -15,6 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens;
@@ -26,7 +27,7 @@ public class HqlSemanticTokensTest {
@BeforeEach
void setup() {
provider = new HqlSemanticTokens(Optional.empty());
provider = new HqlSemanticTokens(Optional.empty(), Optional.of(Assertions::fail));
}
@Test

34
headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java
View File

@@ -17,7 +17,6 @@ import java.util.List;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
@@ -45,7 +44,7 @@ public class JdtDataQuerySemanticTokensProviderTest {
@BeforeEach
public void setup() throws Exception {
jp = projects.mavenProject("boot-sql");
jp = projects.mavenProject("boot-mysql");
}
private List<SemanticTokenData> computeTokens(CompilationUnit cu) {
@@ -342,21 +341,24 @@ public class JdtDataQuerySemanticTokensProviderTest {
assertThat(token).isEqualTo(new SemanticTokenData(156, 157, "variable", new String[0]));
token = tokens.get(7);
assertThat(source.substring(token.start(), token.end())).isEqualTo(".status");
assertThat(token).isEqualTo(new SemanticTokenData(157, 164, "variable", new String[0]));
assertThat(source.substring(token.start(), token.end())).isEqualTo(".");
assertThat(token).isEqualTo(new SemanticTokenData(157, 158, "operator", new String[0]));
token = tokens.get(8);
assertThat(source.substring(token.start(), token.end())).isEqualTo("status");
assertThat(token).isEqualTo(new SemanticTokenData(158, 164, "property", new String[0]));
token = tokens.get(9);
assertThat(source.substring(token.start(), token.end())).isEqualTo("=");
assertThat(token).isEqualTo(new SemanticTokenData(165, 166, "operator", new String[0]));
token = tokens.get(9);
token = tokens.get(10);
assertThat(source.substring(token.start(), token.end())).isEqualTo("1");
assertThat(token).isEqualTo(new SemanticTokenData(167, 168, "number", new String[0]));
}
@Test
@Disabled("Needs proper SPEL support in SQL grammar")
void nativeQueryWithSpel() throws Exception {
String source = """
package my.package
@@ -406,26 +408,30 @@ public class JdtDataQuerySemanticTokensProviderTest {
assertThat(token).isEqualTo(new SemanticTokenData(156, 157, "variable", new String[0]));
token = tokens.get(7);
assertThat(source.substring(token.start(), token.end())).isEqualTo(".status");
assertThat(token).isEqualTo(new SemanticTokenData(157, 164, "variable", new String[0]));
assertThat(source.substring(token.start(), token.end())).isEqualTo(".");
assertThat(token).isEqualTo(new SemanticTokenData(157, 158, "operator", new String[0]));
token = tokens.get(8);
assertThat(source.substring(token.start(), token.end())).isEqualTo("status");
assertThat(token).isEqualTo(new SemanticTokenData(158, 164, "property", new String[0]));
token = tokens.get(9);
assertThat(source.substring(token.start(), token.end())).isEqualTo("=");
assertThat(token).isEqualTo(new SemanticTokenData(165, 166, "operator", new String[0]));
token = tokens.get(9);
token = tokens.get(10);
assertThat(source.substring(token.start(), token.end())).isEqualTo("?");
assertThat(token).isEqualTo(new SemanticTokenData(167, 168, "operator", new String[0]));
token = tokens.get(9);
token = tokens.get(11);
assertThat(source.substring(token.start(), token.end())).isEqualTo("#{");
assertThat(token).isEqualTo(new SemanticTokenData(168, 170, "operator", new String[0]));
token = tokens.get(10);
token = tokens.get(12);
assertThat(source.substring(token.start(), token.end())).isEqualTo("status");
assertThat(token).isEqualTo(new SemanticTokenData(170, 176, "variable", new String[0]));
token = tokens.get(11);
token = tokens.get(13);
assertThat(source.substring(token.start(), token.end())).isEqualTo("}");
assertThat(token).isEqualTo(new SemanticTokenData(176, 177, "operator", new String[0]));
}

3
headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokensTest.java
View File

@@ -15,6 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens;
@@ -26,7 +27,7 @@ public class JpqlSemanticTokensTest {
@BeforeEach
void setup() {
provider = new JpqlSemanticTokens(Optional.empty());
provider = new JpqlSemanticTokens(Optional.empty(), Optional.of(Assertions::fail));
}
@Test

22
headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokensTest.java
View File

@@ -15,6 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens;
@@ -26,20 +27,27 @@ public class MySqlSemanticTokensTest {
@BeforeEach
void setup() {
provider = new MySqlSemanticTokens(Optional.of(new SpelSemanticTokens()));
provider = new MySqlSemanticTokens(Optional.of(new SpelSemanticTokens()), Optional.of(Assertions::fail));
}
@Test
void simple() {
List<SemanticTokenData> tokens = provider.computeTokens("SELECT * from fn_module_candidates()", 0);
List<SemanticTokenData> tokens = provider.computeTokens("SELECT * from Document document WHERE document.id=fn_module_candidates()", 0);
assertThat(tokens.size()).isEqualTo(13);
assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0]));
assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(7, 8, "operator", new String[0]));
assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(9, 13, "keyword", new String[0]));
assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(14, 34, "variable", new String[0]));
assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(34, 35, "operator", new String[0]));
assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(35, 36, "operator", new String[0]));
assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(9, 13, "keyword", new String[0])); // from
assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(14, 22, "variable", new String[0])); // Document
assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(23, 31, "variable", new String[0])); // document
assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(32, 37, "keyword", new String[0])); // WHERE
assertThat(tokens.get(6)).isEqualTo(new SemanticTokenData(38, 46, "variable", new String[0])); // document
assertThat(tokens.get(7)).isEqualTo(new SemanticTokenData(46, 47, "operator", new String[0])); // .
assertThat(tokens.get(8)).isEqualTo(new SemanticTokenData(47, 49, "property", new String[0])); // id
assertThat(tokens.get(9)).isEqualTo(new SemanticTokenData(49, 50, "operator", new String[0])); // =
assertThat(tokens.get(10)).isEqualTo(new SemanticTokenData(50, 70, "method", new String[0])); // fn_module_candidates
assertThat(tokens.get(11)).isEqualTo(new SemanticTokenData(70, 71, "operator", new String[0])); // (
assertThat(tokens.get(12)).isEqualTo(new SemanticTokenData(71, 72, "operator", new String[0])); // )
assertThat(tokens.size()).isEqualTo(6);
}
@Test

84
headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokensTest.java Normal file
View File

@@ -0,0 +1,84 @@
/*******************************************************************************
* Copyright (c) 2024 Broadcom, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Broadcom, Inc. - initial API and implementation
*******************************************************************************/
package org.springframework.ide.vscode.boot.java.data.jpa.queries;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens;
import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.SemanticTokenData;
public class PostgreSqlSemanticTokensTest {
private PostgreSqlSemanticTokens provider;
@BeforeEach
void setup() {
provider = new PostgreSqlSemanticTokens(Optional.of(new SpelSemanticTokens()), Optional.of(Assertions::fail));
}
@Test
void simple() {
List<SemanticTokenData> tokens = provider.computeTokens("SELECT * from fn_module_candidates", 0);
assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0]));
assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(7, 8, "operator", new String[0]));
assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(9, 13, "keyword", new String[0]));
assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(14, 34, "variable", new String[0]));
assertThat(tokens.size()).isEqualTo(4);
}
@Test
void adv_1() {
List<SemanticTokenData> tokens = provider.computeTokens("""
DELETE FROM Represenation representation
WHERE representation.project_id=?1
AND NOT EXISTS (
SELECT * FROM Document document
WHERE document.project_id=?1
AND json_path_exists(document.content::jsonb, ('strict $.content.**.id ? (@ == "\\' || representation.targetobjectid || \\'")')::jsonpath)
)
""", 0);
assertThat(tokens.size()).isEqualTo(43);
assertThat(tokens.get(10)).isEqualTo(new SemanticTokenData(74, 75, "parameter", new String[0])); // 1 from ?1
assertThat(tokens.get(26)).isEqualTo(new SemanticTokenData(154, 155, "parameter", new String[0])); // 1 from ?1
assertThat(tokens.get(28)).isEqualTo(new SemanticTokenData(161, 177, "method", new String[0])); // json_path_exists
assertThat(tokens.get(33)).isEqualTo(new SemanticTokenData(194, 196, "operator", new String[0])); // ::
assertThat(tokens.get(34)).isEqualTo(new SemanticTokenData(196, 201, "type", new String[0])); // ::
assertThat(tokens.get(37)).isEqualTo(new SemanticTokenData(204, 281, "string", new String[0])); // 'strict $.content.**.id ? (@ == "\\' || representation.targetobjectid || \\'")'
assertThat(tokens.get(39)).isEqualTo(new SemanticTokenData(282, 284, "operator", new String[0])); // ::
assertThat(tokens.get(40)).isEqualTo(new SemanticTokenData(284, 292, "type", new String[0])); // ::
}
@Test
void spelInQuery() {
List<SemanticTokenData> tokens = provider.computeTokens("DELETE FROM component_document WHERE item_document_id = :#{someBean}", 0);
assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0]));
assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(7, 11, "keyword", new String[0]));
assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(12, 30, "variable", new String[0]));
assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(31, 36, "keyword", new String[0]));
assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(37, 53, "variable", new String[0]));
assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(54, 55, "operator", new String[0]));
assertThat(tokens.get(6)).isEqualTo(new SemanticTokenData(56, 57, "operator", new String[0]));
assertThat(tokens.get(7)).isEqualTo(new SemanticTokenData(57, 59, "operator", new String[0]));
assertThat(tokens.get(8)).isEqualTo(new SemanticTokenData(59, 67, "variable", new String[0]));
assertThat(tokens.get(9)).isEqualTo(new SemanticTokenData(67, 68, "operator", new String[0]));
assertThat(tokens.size()).isEqualTo(10);
}
}

30
headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java
View File

@@ -47,7 +47,7 @@ public class QueryReconcilerTest {
public void setup() throws Exception {
harness.intialize(null);
directory = new File(ProjectsHarness.class.getResource("/test-projects/boot-sql/").toURI());
directory = new File(ProjectsHarness.class.getResource("/test-projects/boot-mysql/").toURI());
String projectDir = directory.toURI().toString();
@@ -209,7 +209,7 @@ public class QueryReconcilerTest {
}
@Test
void nativeSqlAnnotation() throws Exception {
void nativeMySqlAnnotation() throws Exception {
String source = """
package example.demo;
@@ -229,6 +229,32 @@ public class QueryReconcilerTest {
editor.assertProblems("SELECTX|MySQL: mismatched input 'SELECTX' expecting {'ALTER',");
}
@Test
void nativePostgreSql() throws Exception {
directory = new File(ProjectsHarness.class.getResource("/test-projects/boot-postgresql/").toURI());
String projectDir = directory.toURI().toString();
// trigger project creation
projectFinder.find(new TextDocumentIdentifier(projectDir)).get();
String source = """
package example.demo;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
public interface OwnerRepository extends Repository<Object, Integer> {
@Query(value = "SELECTX ptype FROM PetType", nativeQuery = true)
List<Object> findPetTypes();
}
""";
String docUri = directory.toPath().resolve("src/main/java/example/demo/OwnerRepository.java").toUri()
.toString();
Editor editor = harness.newEditor(LanguageId.JAVA, source, docUri);
editor.assertProblems("ptype|PostgreSQL: no viable alternative at input 'SELECTXptype'");
}
@Test
void noErrorForHql() throws Exception {
String source = """

1
headless-services/spring-boot-language-server/src/test/resources/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/test-projects/**/.mvn/

0
headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/mvnw → headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/mvnw vendored
View File

0
headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/mvnw.cmd → headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/mvnw.cmd vendored
View File

0
headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/pom.xml → headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/pom.xml
View File

308
headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw vendored Executable file
View File

@@ -0,0 +1,308 @@
#!/bin/sh
# ----------------------------------------------------------------------------
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# ----------------------------------------------------------------------------
# ----------------------------------------------------------------------------
# Apache Maven Wrapper startup batch script, version 3.2.0
#
# Required ENV vars:
# ------------------
# JAVA_HOME - location of a JDK home dir
#
# Optional ENV vars
# -----------------
# MAVEN_OPTS - parameters passed to the Java VM when running Maven
# e.g. to debug Maven itself, use
# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
# MAVEN_SKIP_RC - flag to disable loading of mavenrc files
# ----------------------------------------------------------------------------
if [ -z "$MAVEN_SKIP_RC" ] ; then
if [ -f /usr/local/etc/mavenrc ] ; then
. /usr/local/etc/mavenrc
fi
if [ -f /etc/mavenrc ] ; then
. /etc/mavenrc
fi
if [ -f "$HOME/.mavenrc" ] ; then
. "$HOME/.mavenrc"
fi
fi
# OS specific support. $var _must_ be set to either true or false.
cygwin=false;
darwin=false;
mingw=false
case "$(uname)" in
CYGWIN*) cygwin=true ;;
MINGW*) mingw=true;;
Darwin*) darwin=true
# Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
# See https://developer.apple.com/library/mac/qa/qa1170/_index.html
if [ -z "$JAVA_HOME" ]; then
if [ -x "/usr/libexec/java_home" ]; then
JAVA_HOME="$(/usr/libexec/java_home)"; export JAVA_HOME
else
JAVA_HOME="/Library/Java/Home"; export JAVA_HOME
fi
fi
;;
esac
if [ -z "$JAVA_HOME" ] ; then
if [ -r /etc/gentoo-release ] ; then
JAVA_HOME=$(java-config --jre-home)
fi
fi
# For Cygwin, ensure paths are in UNIX format before anything is touched
if $cygwin ; then
[ -n "$JAVA_HOME" ] &&
JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
[ -n "$CLASSPATH" ] &&
CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
fi
# For Mingw, ensure paths are in UNIX format before anything is touched
if $mingw ; then
[ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] &&
JAVA_HOME="$(cd "$JAVA_HOME" || (echo "cannot cd into $JAVA_HOME."; exit 1); pwd)"
fi
if [ -z "$JAVA_HOME" ]; then
javaExecutable="$(which javac)"
if [ -n "$javaExecutable" ] && ! [ "$(expr "\"$javaExecutable\"" : '\([^ ]*\)')" = "no" ]; then
# readlink(1) is not available as standard on Solaris 10.
readLink=$(which readlink)
if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then
if $darwin ; then
javaHome="$(dirname "\"$javaExecutable\"")"
javaExecutable="$(cd "\"$javaHome\"" && pwd -P)/javac"
else
javaExecutable="$(readlink -f "\"$javaExecutable\"")"
fi
javaHome="$(dirname "\"$javaExecutable\"")"
javaHome=$(expr "$javaHome" : '\(.*\)/bin')
JAVA_HOME="$javaHome"
export JAVA_HOME
fi
fi
fi
if [ -z "$JAVACMD" ] ; then
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
else
JAVACMD="$(\unset -f command 2>/dev/null; \command -v java)"
fi
fi
if [ ! -x "$JAVACMD" ] ; then
echo "Error: JAVA_HOME is not defined correctly." >&2
echo " We cannot execute $JAVACMD" >&2
exit 1
fi
if [ -z "$JAVA_HOME" ] ; then
echo "Warning: JAVA_HOME environment variable is not set."
fi
# traverses directory structure from process work directory to filesystem root
# first directory with .mvn subdirectory is considered project base directory
find_maven_basedir() {
if [ -z "$1" ]
then
echo "Path not specified to find_maven_basedir"
return 1
fi
basedir="$1"
wdir="$1"
while [ "$wdir" != '/' ] ; do
if [ -d "$wdir"/.mvn ] ; then
basedir=$wdir
break
fi
# workaround for JBEAP-8937 (on Solaris 10/Sparc)
if [ -d "${wdir}" ]; then
wdir=$(cd "$wdir/.." || exit 1; pwd)
fi
# end of workaround
done
printf '%s' "$(cd "$basedir" || exit 1; pwd)"
}
# concatenates all lines of a file
concat_lines() {
if [ -f "$1" ]; then
# Remove \r in case we run on Windows within Git Bash
# and check out the repository with auto CRLF management
# enabled. Otherwise, we may read lines that are delimited with
# \r\n and produce $'-Xarg\r' rather than -Xarg due to word
# splitting rules.
tr -s '\r\n' ' ' < "$1"
fi
}
log() {
if [ "$MVNW_VERBOSE" = true ]; then
printf '%s\n' "$1"
fi
}
BASE_DIR=$(find_maven_basedir "$(dirname "$0")")
if [ -z "$BASE_DIR" ]; then
exit 1;
fi
MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}; export MAVEN_PROJECTBASEDIR
log "$MAVEN_PROJECTBASEDIR"
##########################################################################################
# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
# This allows using the maven wrapper in projects that prohibit checking in binary data.
##########################################################################################
wrapperJarPath="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar"
if [ -r "$wrapperJarPath" ]; then
log "Found $wrapperJarPath"
else
log "Couldn't find $wrapperJarPath, downloading it ..."
if [ -n "$MVNW_REPOURL" ]; then
wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
else
wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
fi
while IFS="=" read -r key value; do
# Remove '\r' from value to allow usage on windows as IFS does not consider '\r' as a separator ( considers space, tab, new line ('\n'), and custom '=' )
safeValue=$(echo "$value" | tr -d '\r')
case "$key" in (wrapperUrl) wrapperUrl="$safeValue"; break ;;
esac
done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
log "Downloading from: $wrapperUrl"
if $cygwin; then
wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath")
fi
if command -v wget > /dev/null; then
log "Found wget ... using wget"
[ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet"
if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
wget $QUIET "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
else
wget $QUIET --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
fi
elif command -v curl > /dev/null; then
log "Found curl ... using curl"
[ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent"
if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
curl $QUIET -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
else
curl $QUIET --user "$MVNW_USERNAME:$MVNW_PASSWORD" -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
fi
else
log "Falling back to using Java to download"
javaSource="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.java"
javaClass="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.class"
# For Cygwin, switch paths to Windows format before running javac
if $cygwin; then
javaSource=$(cygpath --path --windows "$javaSource")
javaClass=$(cygpath --path --windows "$javaClass")
fi
if [ -e "$javaSource" ]; then
if [ ! -e "$javaClass" ]; then
log " - Compiling MavenWrapperDownloader.java ..."
("$JAVA_HOME/bin/javac" "$javaSource")
fi
if [ -e "$javaClass" ]; then
log " - Running MavenWrapperDownloader.java ..."
("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$wrapperUrl" "$wrapperJarPath") || rm -f "$wrapperJarPath"
fi
fi
fi
fi
##########################################################################################
# End of extension
##########################################################################################
# If specified, validate the SHA-256 sum of the Maven wrapper jar file
wrapperSha256Sum=""
while IFS="=" read -r key value; do
case "$key" in (wrapperSha256Sum) wrapperSha256Sum=$value; break ;;
esac
done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
if [ -n "$wrapperSha256Sum" ]; then
wrapperSha256Result=false
if command -v sha256sum > /dev/null; then
if echo "$wrapperSha256Sum $wrapperJarPath" | sha256sum -c > /dev/null 2>&1; then
wrapperSha256Result=true
fi
elif command -v shasum > /dev/null; then
if echo "$wrapperSha256Sum $wrapperJarPath" | shasum -a 256 -c > /dev/null 2>&1; then
wrapperSha256Result=true
fi
else
echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available."
echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties."
exit 1
fi
if [ $wrapperSha256Result = false ]; then
echo "Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised." >&2
echo "Investigate or delete $wrapperJarPath to attempt a clean download." >&2
echo "If you updated your Maven version, you need to update the specified wrapperSha256Sum property." >&2
exit 1
fi
fi
MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
# For Cygwin, switch paths to Windows format before running java
if $cygwin; then
[ -n "$JAVA_HOME" ] &&
JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME")
[ -n "$CLASSPATH" ] &&
CLASSPATH=$(cygpath --path --windows "$CLASSPATH")
[ -n "$MAVEN_PROJECTBASEDIR" ] &&
MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR")
fi
# Provide a "standardized" way to retrieve the CLI args that will
# work with both Windows and non-Windows executions.
MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $*"
export MAVEN_CMD_LINE_ARGS
WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
# shellcheck disable=SC2086 # safe args
exec "$JAVACMD" \
$MAVEN_OPTS \
$MAVEN_DEBUG_OPTS \
-classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
"-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"

205
headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw.cmd vendored Normal file
View File

@@ -0,0 +1,205 @@
@REM ----------------------------------------------------------------------------
@REM Licensed to the Apache Software Foundation (ASF) under one
@REM or more contributor license agreements. See the NOTICE file
@REM distributed with this work for additional information
@REM regarding copyright ownership. The ASF licenses this file
@REM to you under the Apache License, Version 2.0 (the
@REM "License"); you may not use this file except in compliance
@REM with the License. You may obtain a copy of the License at
@REM
@REM https://www.apache.org/licenses/LICENSE-2.0
@REM
@REM Unless required by applicable law or agreed to in writing,
@REM software distributed under the License is distributed on an
@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
@REM KIND, either express or implied. See the License for the
@REM specific language governing permissions and limitations
@REM under the License.
@REM ----------------------------------------------------------------------------
@REM ----------------------------------------------------------------------------
@REM Apache Maven Wrapper startup batch script, version 3.2.0
@REM
@REM Required ENV vars:
@REM JAVA_HOME - location of a JDK home dir
@REM
@REM Optional ENV vars
@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
@REM e.g. to debug Maven itself, use
@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
@REM ----------------------------------------------------------------------------
@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
@echo off
@REM set title of command window
title %0
@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO%
@REM set %HOME% to equivalent of $HOME
if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
@REM Execute a user defined script before this one
if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
@REM check for pre script, once with legacy .bat ending and once with .cmd ending
if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
:skipRcPre
@setlocal
set ERROR_CODE=0
@REM To isolate internal variables from possible post scripts, we use another setlocal
@setlocal
@REM ==== START VALIDATION ====
if not "%JAVA_HOME%" == "" goto OkJHome
echo.
echo Error: JAVA_HOME not found in your environment. >&2
echo Please set the JAVA_HOME variable in your environment to match the >&2
echo location of your Java installation. >&2
echo.
goto error
:OkJHome
if exist "%JAVA_HOME%\bin\java.exe" goto init
echo.
echo Error: JAVA_HOME is set to an invalid directory. >&2
echo JAVA_HOME = "%JAVA_HOME%" >&2
echo Please set the JAVA_HOME variable in your environment to match the >&2
echo location of your Java installation. >&2
echo.
goto error
@REM ==== END VALIDATION ====
:init
@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
@REM Fallback to current working directory if not found.
set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
set EXEC_DIR=%CD%
set WDIR=%EXEC_DIR%
:findBaseDir
IF EXIST "%WDIR%"\.mvn goto baseDirFound
cd ..
IF "%WDIR%"=="%CD%" goto baseDirNotFound
set WDIR=%CD%
goto findBaseDir
:baseDirFound
set MAVEN_PROJECTBASEDIR=%WDIR%
cd "%EXEC_DIR%"
goto endDetectBaseDir
:baseDirNotFound
set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
cd "%EXEC_DIR%"
:endDetectBaseDir
IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
@setlocal EnableExtensions EnableDelayedExpansion
for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
:endReadAdditionalConfig
SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B
)
@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
if exist %WRAPPER_JAR% (
if "%MVNW_VERBOSE%" == "true" (
echo Found %WRAPPER_JAR%
)
) else (
if not "%MVNW_REPOURL%" == "" (
SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
)
if "%MVNW_VERBOSE%" == "true" (
echo Couldn't find %WRAPPER_JAR%, downloading it ...
echo Downloading from: %WRAPPER_URL%
)
powershell -Command "&{"^
"$webclient = new-object System.Net.WebClient;"^
"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
"}"^
"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^
"}"
if "%MVNW_VERBOSE%" == "true" (
echo Finished downloading %WRAPPER_JAR%
)
)
@REM End of extension
@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file
SET WRAPPER_SHA_256_SUM=""
FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B
)
IF NOT %WRAPPER_SHA_256_SUM%=="" (
powershell -Command "&{"^
"$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^
"If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^
" Write-Output 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
" Write-Output 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
" Write-Output 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
" exit 1;"^
"}"^
"}"
if ERRORLEVEL 1 goto error
)
@REM Provide a "standardized" way to retrieve the CLI args that will
@REM work with both Windows and non-Windows executions.
set MAVEN_CMD_LINE_ARGS=%*
%MAVEN_JAVA_EXE% ^
%JVM_CONFIG_MAVEN_PROPS% ^
%MAVEN_OPTS% ^
%MAVEN_DEBUG_OPTS% ^
-classpath %WRAPPER_JAR% ^
"-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
%WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
if ERRORLEVEL 1 goto error
goto end
:error
set ERROR_CODE=1
:end
@endlocal & set ERROR_CODE=%ERROR_CODE%
if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
@REM check for post script, once with legacy .bat ending and once with .cmd ending
if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
:skipRcPost
@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
if "%MAVEN_BATCH_PAUSE%"=="on" pause
if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
cmd /C exit /B %ERROR_CODE%

48
headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/pom.xml Normal file
View File

@@ -0,0 +1,48 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.2</version>
<relativePath />
</parent>
<artifactId>boot-sql</artifactId>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
</project>

BIN
headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.jar vendored
View File

Binary file not shown.

18
headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.properties vendored
View File

@@ -1,18 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.3/apache-maven-3.9.3-bin.zip
wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar