@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/mips.json

@@ -0,0 +1,185 @@
+{
+  "language": "mips",
+  "definitions": {
+    "add": {
+      "signature": "add $rd, $rs, $rt",
+      "description": "Adds the values in registers rs and rt, storing the result in register rd. Triggers an arithmetic overflow exception if the result exceeds the signed 32-bit integer range.",
+      "type": "function",
+      "module": "R-Type Arithmetic"
+    },
+    "addi": {
+      "signature": "addi $rt, $rs, immediate",
+      "description": "Adds a sign-extended 16-bit immediate value to the contents of register rs and stores the result in register rt. Raises overflow exception on signed overflow.",
+      "type": "function",
+      "module": "I-Type Arithmetic"
+    },
+    "sub": {
+      "signature": "sub $rd, $rs, $rt",
+      "description": "Subtracts the value in register rt from register rs and stores the result in register rd. Triggers an arithmetic overflow exception on signed integer overflow.",
+      "type": "function",
+      "module": "R-Type Arithmetic"
+    },
+    "mul": {
+      "signature": "mul $rd, $rs, $rt",
+      "description": "Multiplies the values in registers rs and rt, storing the lower 32 bits of the result in register rd. A pseudo-instruction in some assemblers that wraps mult and mflo.",
+      "type": "function",
+      "module": "R-Type Arithmetic"
+    },
+    "and": {
+      "signature": "and $rd, $rs, $rt",
+      "description": "Performs a bitwise AND operation between the values in registers rs and rt, storing the result in register rd for masking and flag extraction operations.",
+      "type": "function",
+      "module": "R-Type Logic"
+    },
+    "or": {
+      "signature": "or $rd, $rs, $rt",
+      "description": "Performs a bitwise OR operation between the values in registers rs and rt, storing the result in register rd for combining bit flags or setting specific bits.",
+      "type": "function",
+      "module": "R-Type Logic"
+    },
+    "sll": {
+      "signature": "sll $rd, $rt, shamt",
+      "description": "Shifts the value in register rt left by the specified shift amount of 0 to 31 bits, filling vacated positions with zeros and storing the result in register rd.",
+      "type": "function",
+      "module": "R-Type Shift"
+    },
+    "srl": {
+      "signature": "srl $rd, $rt, shamt",
+      "description": "Shifts the value in register rt right by the specified shift amount of 0 to 31 bits, filling vacated positions with zeros as a logical shift and storing result in register rd.",
+      "type": "function",
+      "module": "R-Type Shift"
+    },
+    "lw": {
+      "signature": "lw $rt, offset($rs)",
+      "description": "Loads a 32-bit word from memory at the address computed by adding the sign-extended offset to register rs, storing the value in register rt. Address must be word-aligned.",
+      "type": "function",
+      "module": "Memory Access"
+    },
+    "sw": {
+      "signature": "sw $rt, offset($rs)",
+      "description": "Stores the 32-bit word from register rt into memory at the address computed by adding the sign-extended offset to register rs. Address must be word-aligned.",
+      "type": "function",
+      "module": "Memory Access"
+    },
+    "lb": {
+      "signature": "lb $rt, offset($rs)",
+      "description": "Loads a byte from memory at the computed address, sign-extends it to 32 bits, and stores the result in register rt. Used for reading signed character data.",
+      "type": "function",
+      "module": "Memory Access"
+    },
+    "sb": {
+      "signature": "sb $rt, offset($rs)",
+      "description": "Stores the least significant byte of register rt into memory at the address computed by adding the sign-extended offset to register rs.",
+      "type": "function",
+      "module": "Memory Access"
+    },
+    "la": {
+      "signature": "la $rt, label",
+      "description": "Pseudo-instruction that loads the 32-bit address of a label into register rt. Typically expands to a lui and ori instruction pair for the upper and lower 16 bits.",
+      "type": "function",
+      "module": "Pseudo-Instructions"
+    },
+    "li": {
+      "signature": "li $rt, immediate",
+      "description": "Pseudo-instruction that loads a 32-bit immediate constant into register rt, expanding to lui and ori as needed depending on the magnitude of the value.",
+      "type": "function",
+      "module": "Pseudo-Instructions"
+    },
+    "beq": {
+      "signature": "beq $rs, $rt, label",
+      "description": "Branch on Equal compares registers rs and rt, and if they are equal, branches to the target label by adding the sign-extended offset to the program counter.",
+      "type": "function",
+      "module": "Branch"
+    },
+    "bne": {
+      "signature": "bne $rs, $rt, label",
+      "description": "Branch on Not Equal compares registers rs and rt, and if they differ, branches to the target label by adding the sign-extended offset to the program counter.",
+      "type": "function",
+      "module": "Branch"
+    },
+    "slt": {
+      "signature": "slt $rd, $rs, $rt",
+      "description": "Set on Less Than sets register rd to 1 if the signed value in rs is less than the signed value in rt, otherwise sets rd to 0. Essential for comparison-based branching.",
+      "type": "function",
+      "module": "R-Type Comparison"
+    },
+    "j": {
+      "signature": "j target",
+      "description": "Unconditional Jump instruction that jumps to the instruction at the specified 26-bit target address, with the upper 4 bits from the current program counter. Used for loops and gotos.",
+      "type": "function",
+      "module": "Jump"
+    },
+    "jal": {
+      "signature": "jal target",
+      "description": "Jump and Link saves the return address PC+4 in register $ra and jumps to the target address. The standard instruction for calling subroutines in MIPS assembly programs.",
+      "type": "function",
+      "module": "Jump"
+    },
+    "jr": {
+      "signature": "jr $rs",
+      "description": "Jump Register jumps to the address stored in register rs. Commonly used with $ra to return from a subroutine called by jal, restoring execution to the caller.",
+      "type": "function",
+      "module": "Jump"
+    },
+    "syscall": {
+      "signature": "syscall",
+      "description": "Triggers a system call to the operating system or simulator. The service number in $v0 with arguments in $a0-$a3. Common services include 1 for print_int, 4 for print_string, 10 for exit.",
+      "type": "function",
+      "module": "System"
+    },
+    "$v0": {
+      "signature": "$v0 (Register 2)",
+      "description": "Value register 0, used for function return values and syscall service numbers. By convention, integer return values from functions are placed in $v0 before returning.",
+      "type": "function",
+      "module": "Registers"
+    },
+    "$a0": {
+      "signature": "$a0 (Register 4)",
+      "description": "Argument register 0, used to pass the first argument to subroutines and syscalls. Part of the $a0-$a3 convention for the first four function parameters in MIPS calling convention.",
+      "type": "function",
+      "module": "Registers"
+    },
+    "$sp": {
+      "signature": "$sp (Register 29)",
+      "description": "Stack Pointer register, pointing to the top of the runtime stack in memory. Grows downward by convention; functions adjust it with addi $sp, $sp, -N to allocate stack frames.",
+      "type": "function",
+      "module": "Registers"
+    },
+    "$ra": {
+      "signature": "$ra (Register 31)",
+      "description": "Return Address register, automatically set by the jal instruction to hold the address of the instruction following the call. Used by jr $ra to return from subroutines.",
+      "type": "function",
+      "module": "Registers"
+    },
+    ".data": {
+      "signature": ".data",
+      "description": "Assembler directive that marks the beginning of the data segment, where variables, strings, and constants are declared using directives like .word, .asciiz, and .byte.",
+      "type": "function",
+      "module": "Directives"
+    },
+    ".text": {
+      "signature": ".text",
+      "description": "Assembler directive that marks the beginning of the code and text segment containing executable instructions. Typically follows the .data section in MIPS assembly programs.",
+      "type": "function",
+      "module": "Directives"
+    },
+    ".globl": {
+      "signature": ".globl label",
+      "description": "Assembler directive that declares a label as globally visible, making it accessible to the linker and other object files. Commonly used with main as the program entry point.",
+      "type": "function",
+      "module": "Directives"
+    },
+    ".asciiz": {
+      "signature": ".asciiz \"string\"",
+      "description": "Assembler directive that stores a null-terminated ASCII string in the data segment, automatically appending a zero byte. Used for strings passed to print_string syscall.",
+      "type": "function",
+      "module": "Directives"
+    },
+    ".word": {
+      "signature": ".word value [, value ...]",
+      "description": "Assembler directive that stores one or more 32-bit integer values in the data segment, each occupying four consecutive bytes with proper word alignment.",
+      "type": "function",
+      "module": "Directives"
+    }
+  }
+}

package/data/defination/msdax.json

@@ -0,0 +1,125 @@
+{
+  "language": "msdax",
+  "definitions": {
+    "CALCULATE": {
+      "signature": "CALCULATE(expression, filter1, filter2, ...) -> Scalar",
+      "description": "Evaluates an expression in a modified filter context created by applying zero or more filter arguments. The most important DAX function, enabling context transition and dynamic measure recalculation.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "FILTER": {
+      "signature": "FILTER(table, filter_expression) -> Table",
+      "description": "Returns a table that represents a subset of another table or expression, containing only rows where the filter expression evaluates to TRUE. Commonly used inside CALCULATE and iterator functions.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "ALL": {
+      "signature": "ALL(table_or_column, ...) -> Table",
+      "description": "Returns all rows in a table or all values in a column, ignoring any filters that have been applied. Essential for calculating ratios, percentages, and grand totals against the unfiltered dataset.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "ALLEXCEPT": {
+      "signature": "ALLEXCEPT(table, column1, column2, ...) -> Table",
+      "description": "Removes all context filters from the specified table except for the filters on the listed columns, enabling subtotal calculations that preserve certain dimensional groupings.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "RELATED": {
+      "signature": "RELATED(column) -> Scalar",
+      "description": "Returns a related value from another table using an established relationship. Follows many-to-one relationships to retrieve a single value from the lookup table for each row context.",
+      "type": "function",
+      "module": "Relationship"
+    },
+    "RELATEDTABLE": {
+      "signature": "RELATEDTABLE(table) -> Table",
+      "description": "Returns a table of rows related to the current row context by following one-to-many relationships, equivalent to CALCULATETABLE with the related table applying row context as filter.",
+      "type": "function",
+      "module": "Relationship"
+    },
+    "SUMX": {
+      "signature": "SUMX(table, expression) -> Scalar",
+      "description": "Iterates over each row of the specified table and evaluates the expression, then returns the sum of all evaluated values. Enables row-by-row calculations before aggregation.",
+      "type": "function",
+      "module": "Aggregation"
+    },
+    "AVERAGEX": {
+      "signature": "AVERAGEX(table, expression) -> Scalar",
+      "description": "Iterates over each row of the specified table and evaluates the expression, then returns the arithmetic mean of all evaluated values. Blank values are excluded from the calculation.",
+      "type": "function",
+      "module": "Aggregation"
+    },
+    "COUNTROWS": {
+      "signature": "COUNTROWS(table) -> Integer",
+      "description": "Counts the number of rows in the specified table or table expression, including rows with blank values. Returns a whole number representing the row count of the evaluated table.",
+      "type": "function",
+      "module": "Aggregation"
+    },
+    "VALUES": {
+      "signature": "VALUES(column_or_table) -> Table",
+      "description": "Returns a one-column table of distinct values from the specified column in the current filter context, including the blank row added for referential integrity violations.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "EARLIER": {
+      "signature": "EARLIER(column, number) -> Scalar",
+      "description": "Returns the value of the specified column in an outer row context when nested row contexts exist, commonly used in calculated columns to compare current row values against outer iterations.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "DIVIDE": {
+      "signature": "DIVIDE(numerator, denominator, alternate_result) -> Scalar",
+      "description": "Performs safe division of numerator by denominator, returning the alternate result (default BLANK) when the denominator is zero, avoiding division-by-zero errors in measures.",
+      "type": "function",
+      "module": "Math"
+    },
+    "IF": {
+      "signature": "IF(logical_test, value_if_true, value_if_false) -> Scalar",
+      "description": "Evaluates a logical condition and returns one of two values based on whether the condition is TRUE or FALSE, supporting conditional logic in calculated columns and measures.",
+      "type": "function",
+      "module": "Logical"
+    },
+    "SWITCH": {
+      "signature": "SWITCH(expression, value1, result1, ..., else_result) -> Scalar",
+      "description": "Evaluates an expression against a list of values and returns the corresponding result, or an optional else result. More readable than nested IF statements for multi-condition logic.",
+      "type": "function",
+      "module": "Logical"
+    },
+    "SELECTEDVALUE": {
+      "signature": "SELECTEDVALUE(column, alternate_result) -> Scalar",
+      "description": "Returns the value when the filter context for the column has been filtered down to a single distinct value, otherwise returns the alternate result or BLANK for slicer-driven calculations.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "DATEADD": {
+      "signature": "DATEADD(dates, number_of_intervals, interval) -> Table",
+      "description": "Returns a table of dates shifted by the specified number of intervals (DAY, MONTH, QUARTER, YEAR) from the dates in the current filter context, enabling period-over-period time intelligence.",
+      "type": "function",
+      "module": "Time Intelligence"
+    },
+    "TOTALYTD": {
+      "signature": "TOTALYTD(expression, dates, filter, year_end_date) -> Scalar",
+      "description": "Evaluates a year-to-date total for the given expression over the specified date column, optionally with a custom fiscal year-end date and additional filters for time intelligence.",
+      "type": "function",
+      "module": "Time Intelligence"
+    },
+    "SAMEPERIODLASTYEAR": {
+      "signature": "SAMEPERIODLASTYEAR(dates) -> Table",
+      "description": "Returns a table containing a column of dates shifted one year back from the dates in the current filter context, commonly used within CALCULATE for year-over-year comparison measures.",
+      "type": "function",
+      "module": "Time Intelligence"
+    },
+    "RANKX": {
+      "signature": "RANKX(table, expression, value, order, ties) -> Integer",
+      "description": "Returns the ranking of a value in a table for the given expression, with configurable sort order (ASC or DESC) and tie-breaking behavior for SKIP or DENSE ranking.",
+      "type": "function",
+      "module": "Aggregation"
+    },
+    "ISBLANK": {
+      "signature": "ISBLANK(value) -> Boolean",
+      "description": "Returns TRUE if the specified value is BLANK, the special DAX empty state. Useful for handling missing data, null values, and referential integrity gaps in data models.",
+      "type": "function",
+      "module": "Information"
+    }
+  }
+}

package/data/defination/mysql.json

@@ -0,0 +1,149 @@
+{
+  "language": "mysql",
+  "definitions": {
+    "CONCAT": {
+      "signature": "CONCAT(str1, str2, ...) -> VARCHAR",
+      "description": "Concatenates two or more string arguments into a single string. Returns NULL if any argument is NULL. For NULL-safe concatenation, use CONCAT_WS or IFNULL wrappers.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "CONCAT_WS": {
+      "signature": "CONCAT_WS(separator, str1, str2, ...) -> VARCHAR",
+      "description": "Concatenates strings with a separator between each pair, automatically skipping NULL values. The first argument is the delimiter used between the remaining arguments.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "SUBSTRING": {
+      "signature": "SUBSTRING(str, pos, len) -> VARCHAR",
+      "description": "Extracts a substring from the given string starting at position pos (1-based) for len characters. Negative pos counts from the end. Also aliased as SUBSTR and MID.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "REPLACE": {
+      "signature": "REPLACE(str, from_str, to_str) -> VARCHAR",
+      "description": "Returns a string with all occurrences of from_str replaced by to_str in the original string. The search is case-sensitive and does not support regular expressions.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "LENGTH": {
+      "signature": "LENGTH(str) -> INT",
+      "description": "Returns the length of the string in bytes. For multi-byte character sets use CHAR_LENGTH instead, which returns the number of characters regardless of encoding.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "NOW": {
+      "signature": "NOW() -> DATETIME",
+      "description": "Returns the current date and time as a DATETIME value in YYYY-MM-DD HH:MM:SS format. The value is determined at statement execution start and remains constant within the statement.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "CURDATE": {
+      "signature": "CURDATE() -> DATE",
+      "description": "Returns the current date as a DATE value in YYYY-MM-DD format without the time component. Equivalent to CURRENT_DATE and useful for date-only comparisons and filters.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "DATE_FORMAT": {
+      "signature": "DATE_FORMAT(date, format) -> VARCHAR",
+      "description": "Formats a date value according to the specified format string using specifiers like %Y for 4-digit year, %m for month, %d for day, %H for hour, %i for minute, %s for second.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "DATEDIFF": {
+      "signature": "DATEDIFF(date1, date2) -> INT",
+      "description": "Returns the number of days between two date or datetime expressions, calculated as date1 minus date2. Only the date parts are used in the calculation, ignoring time components.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "DATE_ADD": {
+      "signature": "DATE_ADD(date, INTERVAL value unit) -> DATE/DATETIME",
+      "description": "Adds a time interval to a date or datetime value. Units include SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR, and compound units like DAY_HOUR.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "IF": {
+      "signature": "IF(condition, value_if_true, value_if_false) -> ANY",
+      "description": "Evaluates a boolean condition and returns the second argument if true or the third argument if false. A concise inline conditional expression for SELECT lists and computed columns.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "IFNULL": {
+      "signature": "IFNULL(expr1, expr2) -> ANY",
+      "description": "Returns expr1 if it is not NULL, otherwise returns expr2. A concise NULL-handling function commonly used to provide default values for potentially NULL columns or expressions.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "COALESCE": {
+      "signature": "COALESCE(value1, value2, ...) -> ANY",
+      "description": "Returns the first non-NULL value in the argument list, or NULL if all arguments are NULL. Standard SQL function for cascading fallback values across multiple nullable expressions.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "CASE": {
+      "signature": "CASE expr WHEN val THEN result ELSE default END -> ANY",
+      "description": "Provides conditional logic in SQL expressions with two forms: simple comparing an expression to values, and searched evaluating boolean conditions. Returns the matching or ELSE result.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "COUNT": {
+      "signature": "COUNT(expr) -> BIGINT",
+      "description": "Aggregate function that returns the number of non-NULL values in the expression. COUNT(*) counts all rows including NULLs. COUNT(DISTINCT expr) counts unique non-NULL values.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "SUM": {
+      "signature": "SUM(expr) -> DECIMAL/DOUBLE",
+      "description": "Aggregate function that returns the sum of all non-NULL values in the expression. Returns NULL if there are no matching rows. Works with numeric types and implicit conversion.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "AVG": {
+      "signature": "AVG(expr) -> DOUBLE",
+      "description": "Aggregate function that returns the arithmetic mean of non-NULL values in the expression. NULL values are excluded from both the sum and count used in the average calculation.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "GROUP_CONCAT": {
+      "signature": "GROUP_CONCAT([DISTINCT] expr [ORDER BY col] [SEPARATOR str]) -> VARCHAR",
+      "description": "Aggregate function that concatenates values from multiple rows into a single string, with optional DISTINCT filtering, ORDER BY sorting, and custom SEPARATOR (default comma).",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "JSON_EXTRACT": {
+      "signature": "JSON_EXTRACT(json_doc, path[, path ...]) -> JSON",
+      "description": "Extracts data from a JSON document at the specified JSONPath expression. Returns NULL if the path does not exist. The ->> operator unquotes the result to a string.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "JSON_OBJECT": {
+      "signature": "JSON_OBJECT(key, value[, key, value ...]) -> JSON",
+      "description": "Creates a JSON object from the specified key-value pairs. Keys must be strings and are automatically quoted. Values are converted to appropriate JSON types.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "JSON_ARRAYAGG": {
+      "signature": "JSON_ARRAYAGG(expr) -> JSON",
+      "description": "Aggregate function that collects values from multiple rows into a JSON array. Preserves NULL values as JSON null elements within the resulting array output.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "CAST": {
+      "signature": "CAST(expr AS type) -> type",
+      "description": "Converts an expression to the specified data type. Supported target types include CHAR, DATE, DATETIME, DECIMAL, SIGNED, UNSIGNED, BINARY, JSON, and spatial types.",
+      "type": "function",
+      "module": "Cast Functions"
+    },
+    "ROW_NUMBER": {
+      "signature": "ROW_NUMBER() OVER (PARTITION BY col ORDER BY col) -> BIGINT",
+      "description": "Window function that assigns a unique sequential integer to each row within its partition, ordered by the specified columns. Available in MySQL 8.0+ for ranking and pagination.",
+      "type": "function",
+      "module": "Window Functions"
+    },
+    "RANK": {
+      "signature": "RANK() OVER (PARTITION BY col ORDER BY col) -> BIGINT",
+      "description": "Window function that assigns a rank to each row within its partition with gaps for ties. Equal values receive the same rank, and the next rank skips accordingly.",
+      "type": "function",
+      "module": "Window Functions"
+    }
+  }
+}