Skip to main content

​
2025

​
Oxla 1.76.0 - 12/05/25

  • Support for casting:
    • TIMESTAMP WITH TIME ZONE to DATE
    • TIMESTAMP WITHOUT TIME ZONE to TIME WITHOUT TIME ZONE
    • DATE and TIME to TEXT
  • Support for INSERT INTO with SELECT on tables with array columns
  • Mechanism for automatic recovery from a state where inserting data into a table is not possible due to Oxla’s crash
  • Support for MAKE_TIME(), CURRENT_TIMESTAMP(), MAKE_DATE(), DATE(), MAKE_TIMESTAMP(), MAKE_INTERVAL() and MAKE_TIMESTAMPTZ() functions
  • Support for extracting elements from date and timestamp (Doy (day of year), Dow (day of week), Epoch (sec since 1970-01-01), Quarter (quarter of the year)
  • Support for milliseconds and microseconds using EXTRACT() function
  • oxla_internal.oxla_role now contains an additional user_kind column. In case of already existing home, a migration will add this column automatically if necessary
  • Multiplication and division of INTERVALs by numbers use a marginally slower, but more accurate mode of calculation. Previous (faster, but less accurate) behaviour can be switched on with an optional runtime flag
  • Error handling in the CSV reader is now PostgreSQL compliant. Added a specific error message for cases where a CSV file has fewer columns than the table during COPY statement execution
  • fast_commit.enable_migration flag. After this change, if home’s version comes from the time before Fast Commit feature release, the migration to the most recent version of home will always be done
  • Support for user-defined types
  • CREATE TYPE, DROP TYPE, and ALTER TYPE statements got disabled
  • pg_type now contains only built-in types
  • Incorrect hoisting of COUNT(*) aggregations
  • ORDER BY incorrect sorting of INTERVAL values (ex. placing 31 days before 1 month)
  • Bug causing comparison of INTERVAL values to return incorrect results for equivalent values (e.g. 30 days = 1 month would return false)
  • Bug causing INTERVALs' >= operator to return potentially incorrect results for all values other than the last few
  • Bug causing exclusion of equivalent values in RANGE frames when ordering by an INTERVAL column
  • Bug causing tables indexed over INTERVAL columns to order values incorrectly
  • Bug causing incorrect results when JOINing tables with equivalent INTERVAL values (ex. 30 days != 1 month)
  • Bug where queries that contained LIMIT/OFFSET NULL would crash Oxla
  • CURRENT_TIMESTAMP() function behaviour not returning timestamp with timezone
  • Bug causing some GROUP BY queries to return incorrect results or crash the server
  • Bug with NULL literal casting and negation
  • Bug where casting to TIME or DATE could be erroneously optimised out
  • Double casts expression returning error in some cases
  • MIN() and MAX() functions behaviour for the following type of queries: SELECT MIN(x) FROM y
  • Bug causing a crash if a query contained a negative (typed) NULL literal (ex. -NULL::INT4)
  • Developed significant performance improvement for WHERE … IN (…) clauses
  • Fixing INTERVAL support in this release breaks the backwards compatibility for this feature, and will lead to possible loss of data for tables indexed over INTERVAL columns

​
Oxla 1.68.0 - 21/03/25

  • CEILING alias for CEIL() function
  • Support for PI() function
  • Support for conditional expressions on array columns
  • Bug causing non-deterministic planning error for particular arrangement of very complex expressions
  • unix_micros / millis / seconds functions
  • Bug causing some math functions to fail when the input expression performed arithmetic operations on NULL values
  • Bug causing incorrect and inconsistent stringification of INTERVAL types
  • Bug causing queries that involved UPDATE and DELETE mutations to consume too much RAM
  • Bug with aliased literals that caused them to be constant folded incorrectly and possibly overridden
  • Bug regarding literals, argument-less functions and COUNT(*) function, causing them to fail to plan with message about them not being a groupby key
  • Bug with “Function is not supported” error, when using COUNT(*) in WHERE clauses

​
Oxla 1.66.0 - 06/03/25

  • Bug causing ordered-set aggregate functions to fail on large datasets
  • Bug where AVG function would return a division by zero error if the denominator contained a NULL value
  • Bug causing division of NULL value by 0 to return error, instead of NULL
  • Bug where nested SELECT statements would not resolve DISTINCT aggregations correctly
  • Behaviour of DROP USER IF EXISTS / DROP ROLE IF EXISTS. Previously, it was equivalent to DROP USER
  • Occasional crashes in scenarios when Oxla consumes nearly all available RAM amount. The fix increases safety memory margin by two times. After the change, Oxla returns out of memory error in cases when it used to crash
  • Bug causing incorrect results of DATE_TRUNC function on nullable data
  • Crash happening when extracting an element from an array literal without any NULL values
  • Bug resulting in planning error for certain window functions usage pattern involving nested SELECT statements
  • Bug resulting in planning error for window functions usage inside WITH clauses

​
Oxla 1.64.0 - 17/02/25

  • Explicit casts of literals and columns from TEXT type to any other simple type
  • Support for regexp_match() function
  • Crash due to out of memory error when inserting enormous amounts of data with a single INSERT INTO statement
  • Bugs related to analytical window functions utilizing nested SELECT statements, which caused either returning incorrect results or failing to plan for certain queries

​
Oxla 1.63.0 - 10/02/25

  • Adjusted objects visibility in information_schema, pg_catalog and system schemas. Users can now see all objects listed in these tables, when they have grants to a given object or parent schema
  • Support for ON_ERROR parameter for COPY FROM operations on CSV files. From now on, users can ignore invalid rows and keep the correct ones in the table
  • COPY FROM operations utilizing ORC and Parquet formats allow for converting numeric types into timestamp or date
  • COPY FROM operations utilizing ORC and Parquet formats have more meaningful errors
  • Error when a result of an aggregation or a window function from a subquery was used in a JOIN clause
  • Bug that used to prevent from using a result of a window function in an aggregation function in some expressions
  • Bug causing incorrect display of an array consisting of empty string values
  • Bug in aggregation functions, which caused them to return incorrect results for certain queries utilizing nested SELECT statements

​
Oxla 1.60.0 - 20/01/25

  • COPY FROM statements now support Parquet format
  • Support for ARRAY data type
  • Support for to_char(interval, string) function
  • Initial password for Oxla superuser can now be set via ACCESS_CONTROL__INITIAL_PASSWORD config variable (doesn’t need to be present in subsequent Oxla starts)
  • Support for SSL connections
  • Limited support for Window Functions
    • WINDOW and OVER clauses syntax
    • COUNT(), DENSE_RANK(), LAG(), LEAD(), PERCENT_RANK(), RANK(), ROW_NUMBER(), SUM() functions
    • Only ROWS frame mode (no support for GROUPS and RANGE frame modes yet)
    • No support for frame exclusion yet
  • Significant speedup of COPY FROM statements from S3 for smaller .orc files (~1GB)
  • Significant speedups for queries with limit on big data (tested on 100 TB)
  • information_schema.role_table_grants returns only real privileges that the superuser has on tables
  • Additional automatic conversions between types when loading ORC files
  • Old dynamic leader election algorithm (leader must be specified via leader_election.leader_name config variable)
  • Config variables related to old dynamic leader election algorithm: forced_revoke_timeout, min_election_timeout and max_election_timeout
  • Improved error messages on connection errors
  • Bug where a specific error would not be reported, if the SELECT sub-query expression contained table expressions (e.g. GROUP BY)
  • Bug causing wrong results cross-joining two SELECT statements when one of them includes COUNT(*) FROM table
  • Various deadlocks in multiple edge-case scenarios, when using LIMIT and OFFSET in JOIN and UNION statements
  • Deadlock in GROUP BY queries using nested queries with ORDER BY keyword and LIMIT clause
  • Connecting to the follower node on startup, when leader is not initialised yet (returns error instead of freezing)
  • Bug in SELECT statements with common subexpression optimisation resulting in data being overriden by other expression for particular cases utilizing JOIN clauses
  • Larger parquet files should no longer have issues with memory consumption
  • Bug where elements extracted from arrays would resolve incorrectly to an array type instead of the base type
  • Bug preventing from passing a value of type TIMESTAMPTZ to the EXTRACT() function
  • Swapped types in the error message regarding incompatible types in the JOIN ON clause
  • Bug where some configuration options would be ignored for Azure Blob Storage

​
2024

​
Oxla 1.53.0 - 27/11/24

  • Access Control (newly created Oxla Homes have it enabled by default)
  • Support for C# Dapper via Npgsql connector
  • Support for DROP USER syntax
  • Support for pg_authid, pg_shadow, pg_roles and pg_user tables
  • Limited DISTINCT support in aggregation functions
  • Support for FETCH NEXT N ROWS ONLY syntax as a syntactic sugar for LIMIT
  • Reported server Postgres version to 16.0
  • Corrupted ORC files no longer crash Oxla. COPY table(columns) FROM no longer leads to error-related null constraint
  • Issue with COPY FROM statements for ORC format. Files that contained null values, used to sporadically insert them in cells instead of the value
  • Crashes happening during JOIN operation when the query reached out of memory state
  • Bug where a specific case of UPDATE on indexed tables used to lead to data loss
  • In case of virtual machine issues, users should configure max_mem_count increasing the memory map areas, in the following way: sysctl -w vm.max_map_count=262144
  • On old Oxla Homes, access control is disabled by default and users have to turn it on explicitly

​
Oxla 1.51.0 - 05/11/24

  • Support for WITH statements
  • Support for Java Database Connectivity (JDBC) API
  • New virtual tables:
    • pg_catalog.pg_auth_members
    • information_schema.role_usage_grants
    • information_schema.role_table_grants
  • New network.slots_port config option, that configures TCP port used for data exchange between nodes during query execution (defaults to 5770)
  • Oxla now uses two distinct TCP ports for internal cluster communication - one for cluster orchestration (network.port) and one for data exchange (network.slots_port)
  • / and . date separators are accepted in timestamps
  • COPY FROM for an ORC format is now multithreaded, which comes with speed improvements
  • COPY FROM for an ORC format allows for skipping trailing nullable columns
  • Significant improvement of handling queries with LIMIT clause, for cases in which query can end before scanning all input
  • Increased PostgreSQL compatibility of returned error types during planning phase
  • Improvements in timestamp parsing performance
  • Bug where mutation could not be run, once the previous one has ran out of available memory

​
Oxla 1.48.0 - 23/10/24

  • Support for INT4 and INT8 type aliases
  • Support for values of interval type in SUM() function
  • Support for optional parentheses around values in the INSERT statements
  • Support for date, time and time with timezone types in COPY FROM statement with ORC files
  • Support for VERSION function
  • Faster parallel execution of INSERT statements
  • Oxla logs regarding internode disconnections now have warning severity instead of an error
  • Improved and compatible with PostgreSQL error messaging when schema / table does not exist
  • oxla_internal.oxla_home_files paths are relative to Oxla home location
  • RESULT is no longer a keyword
  • ROUND() behavior is aligned with PostgreSQL, so it rounds to the nearest even number
  • Virtual table file path is relative to Oxla home location
  • Oxla now returns error when SELECT statement contains multiple ORDER BY, LIMIT and OFFSET clauses
  • Validation for DROP TABLE in write-protected namespaces. For example DROP TABLE pg_catalog.pg_class used to crash Oxla, while now it returns permission denied for schema pg_catalog
  • Out of bounds reads that used to happen if GROUP BY was used internally during execution of a query
  • Bug where specific case of JOIN used to fail in Oxla Planner
  • Copying from ORC. Loading files bigger than 8192 rows used to have wrong results
  • Putting ' or ; in comments no longer results in syntax error
  • Data race that occurred in internode communication

​
Oxla 1.42.0 - 2/9/24

  • Support for additional option with interval literal, which trims down the output. Here are the possible options:
    • YEAR, MONTH, DAY, HOUR, MINUTE, SECOND
    • YEAR TO MONTH, DAY TO HOUR, DAY TO MINUTE, DAY TO SECOND, HOUR TO MINUTE, HOUR TO SECOND, MINUTE TO SECOND
    • Examples:
      • SELECT INTERVAL '1' HOUR -> 01:00:00
      • SELECT INTERVAL '1 YEAR 2 MONTH' YEAR -> 1 year
      • SELECT INTERVAL '1-2 3 day 04:05:06.070809' DAY TO HOUR -> 1 year 2 months 3 days 04:00:00
  • New oxla_db_event_journal_size Prometheus metric to probe OXLA events journal size
  • Support for SIGN() mathematical function
  • Support for date with dash format
  • Improved support for PostgreSQL COPY syntax:
    • CSV is accepted as an import option without FORMAT preceding it
    • HEADER without any other specification is treated as HEADER ON
    • WITH is supported without parenthesis
    • DELIMITER and NULL import options can be followed by AS
  • Extended support for interval literal, e.g. SELECT INTERVAL '2-1' -> 2 years 1 month
    • Now supports unit abbreviations and short forms:
      • Year: y, yr, yrs
      • Day: d
      • Hour: h, hr, hrs
      • Minute: min, mins, m
      • Second: s, sec, secs
      • Millisecond: ms
    • Added support for weeks, e.g. 1 week, 2 weeks
  • Minor improvements in readability of error messages regarding invalid operations on non-user tables and on write-protected namespaces and tables. For example:
    • INSERT INTO information_schema.tables used to return relation "tables" does not exist error, while now it returns relation "information_schema.tables" does not exist or is not user table
    • INSERT INTO pg_catalog.pg_attrdef values... used to result in relation, pg_catalog.pg_attrdef does not exist or is not user table error, while now it returns permission denied for table pg_catalog.pg_attrdef
  • The docker entry-point now changes ownership of /oxla/data, /oxla/logs and /oxla/crash directories to oxla:oxla
  • Logs that print queries won’t expose confidential data like S3 keys anymore
  • Issue which caused InvalidPart Message: One or more of the specified parts could not be found error when copying data from CSV
  • Bugs where DELETE/UPDATE statements would incorrectly return other modification of table is in progress when restarting Oxla

​
Oxla 1.38.0 - 9/8/24

  • “+” Operator for timestamptz and interval
  • “+” Operator for interval and timestamptz
  • “-” Operator for timestamptz and interval
  • MIN and MAX functions for text columns
  • TCP KeepAlive support for PostgreSQL protocol connections available through network.postgresql_keepalive.* configuration
  • New PostgreSQL protocol connection metrics:
    • oxla_net_postgres_nonlocalhost_connections_count - number of active non-localhost connections
    • oxla_net_postgres_last_nonlocalhost_connection - timestamp of last non-localhost connection event [seconds]
    • oxla_net_postgres_last_nonlocalhost_disconnection - timestamp of last non-localhost disconnection event [seconds]
    • oxla_net_postgres_last_query_started - timestamp of last client query started event [seconds]
    • oxla_net_postgres_last_query_finished - timestamp of last client query finished event [seconds]
    • oxla_net_postgres_queries_ongoing - number of currently running client queries
  • Oxla images now handle new OXLA_LOG_FILE environment variable. It redirects Oxla process logs to a given file inside the container
  • On startup, each Engine node checks access to OXLA_HOME
  • Support for scientific notation in literals, e.g., SELECT 1.1e+3
  • Support for ORDER BY keyword for timestampz
  • Non-reserved keywords in parser, which can be used as database objects’ names
  • Removed a new line in error logs with nested errors
  • Changed object identifiers (OIDs) assignability mechanism. OIDs of user-created tables, types, and namespaces will start from 16384, similar to PostgreSQL. This applies only to Oxla instances with a newly created OXLA_HOME; for existing OXLA_HOME, OIDs will be assigned as before
  • Removed file_name column from oxla_home_files
  • Enabled IF NOT EXISTS for CREATE TABLE and CREATE SCHEMA
  • Enabled IF EXISTS for DROP SCHEMA
  • Bumped minor file format version. Oxla supports both new and old versions
  • Changed default database name to ‘oxla’ (lowercase)
  • COPY TO CSV file will now terminate each row with Unix-style newline (“\n”) instead of Windows/MS-DOS carriage return/newline (“\r\n”)
  • Oxla now discards extended query flow requests after any error until Sync is issued by the frontend
  • Fixed unbounded memory growth after query failure during startup
  • Fixed empty strings and random numbers output in Oxla home files
  • Fixed error message when trying to access a nonexistent table: table identifier is now included in the message
  • Fixed unexpected error with SELECT * inside UNION clause
  • Oxla data directory must be writable to perform automatic data migration. The migration is needed due to the change of the default database name

​
Oxla 1.32.0 - 24/6/24

  • Faster LIKE operator
  • Experimental support for COPY FROM with ORC binary format to load data
  • Equality operator support for JSON objects (key-order-sensitive, opposite to PostgreSQL)
  • Experimental support for Azure Blob Storage
  • Experimental support for Google Cloud Storage
  • Metric showing per node internal bookkeeping tasks capacity
  • New config parameter: insertion. large_copy_buffer_size_limit (default 128M). Increasing it can speed up COPY FROM statements pipeline at the cost of greater memory usage
  • receipts_received_total metrics
  • Support for binary serialization of query results in PostgreSQL protocol
  • Date returned as string will always have two digits for month / day (with 0 prefix if needed). For example: select '2024-5-13'::date used to return 2024-5-13, from now on it will return 2024-05-13
  • Improved stability of PostgreSQL protocol handling
  • Several times faster LIKE operator
  • Increased speed of the COPY FROM statements pipeline and reduced the number of storage requests 7 times
  • task_capacity_total metric
  • regex_replace will work similar as in PostgreSQL, replacing all occurrences only with ‘g’ flag (otherwise replacing only one)
  • Small memory leaks in OpenSSL usage
  • Issues when null was used as a parameter instead of a literal string
  • Increased stability for large COPY FROM queries
  • Fixed Issue that sometimes prevented internall bookkeeping tasks from finishing successfuly

​
Oxla 1.27.0 - 12/5/24

  • Faster LIKE operator
  • Faster GROUP BY when at least one of the key columns has TEXT type
  • Verbose level logs generator by pgbouncer when debug flag is added
  • Support for TRUNCATE table
  • Added parameters to initial response when postgres protocol client connects to Oxla: TimeZone and integer_datetimes. This is needed for compatibility with some external tools
  • Faster scanning over TEXT and JSON columns in hot run
  • Experimental support for Google Cloud Storage
  • Incoming connections from localhost (127.0.0.1) will no longer be logged on info, which will remove internal healthcheck log spam
  • Rare issues causing queries to hang when executing a high volume of INSERT, UPDATE and DELETE queries in rapid succession
  • Problem with setting up connection between nodes
  • Error during planning query containing duplicating expressions in UNION, INTERSECT or EXCEPT
  • LEFT and FULL JOIN returning wrong results on multiple nodes in some situations
  • A bug where using COUNT function without any parameters caused a crash
  • Some cases where regexp_replace worked incorrectly. For example select regexp_replace(‘123x’, ’(\d+)’, ‘abc’) returned abcabcx, now it correctly returns abcx

​
Oxla 1.20.0 - 4/4/24

  • pg_table_is_publishable function was added, takes regclass as parameter (table oid or name) and returns whether relation is publishable. Oxla doesn’t support publishing hence it always returns false
  • Added support for TIME and JSON types in IN expressions
  • Added pg_table_size function takes one parameter which is table regclass and returns it’s size
  • Quote_Ident function mimicking Quote_Ident from postgres
  • Add function POSITION(str IN substr), that works the same as STRPOS
  • Parser accepts now both LF and CRLF as line break
  • Updated metric for oxla internal tasks handling
  • Very limited support for pg_catalog.pg_proc table
  • Add function pg_catalog.pg_get_constraintdef although descriptions are not supported by Oxla, so it always returns null
  • substring function (it works the same as substr)
  • pg_table_is_visible function now also returning whether index associated to given oid is visible within current search_path
  • Function format_type. It works similar as in Postgres (but only for data types supported in Oxla)
  • pg_table_is_visible function returning whether table associated to given oid is visible within current search_path
  • Added support for time zones in case, when the OXLA server does not have access to the internet
  • Added flags to the oxla config enabling fast commits
  • Functions shobj_description and col_description added. They always return null, as Oxla does not support “comment on”
  • added empty tables for tools satisfaction: pg_policy, pg_statistic_ext, pg_publication, pg_publication_rel, pg_publication_namespace, pg_inherits
  • pg_get_userbyid function returning username associated to given oid
  • OID generated for index (visible in pg_index and pg_class metatables) will be different for each new index. Previously it was always 0 (and it will remain 0 for indices created on older oxla version)
  • set datestyle = 'ISO, MDY'; is supported (or simply ‘ISO’), but does nothing as ISO, MDY is default value. This is required by some connectors/tools
  • Removes arithmetic expression from GROUP BY columns if they are neutral for aggregation (e. g. changes A + 4 into A)
  • Optimization, transforms SUM(A + k) into SUM(A) + k * COUNT(*)
  • Much faster ORDER BY col LIMIT BY ... where col is a scalar column (integer, floating point, boolean or string)
  • Faster SUM operation in aggregation over whole table over INTEGER, LONG, FLOAT, DOUBLE non nullable columns
  • Faster MIN, MAX operation in aggregation over whole table over INTEGER, FLOAT, DOUBLE non nullable columns
  • Faster <> operator comparing INTEGER and LONG types with literal (e. g. my_col <> 53)
  • ~5x faster LENGTH function
  • Operator <> works faster when comparing with constant
  • Minor performance improvement of WHERE and JOIN operations
  • Removed implementation implementation detail fields from defaultly generated config file
  • Changed type names in pg_catalog.pg_type, so they match the ones in Postgres. This change applies only to how type names are shown in pg_type (Oxla handles types exactly the same as before). Changed names: integer -> int4, real -> float4, boolean -> bool, bigint -> int8, double precision -> float8, timestamp without time zone -> timestamp, timestamp with time zone -> timestamptz, time without time zone -> time
  • Faster/cheaper CSV reading speed on S3 due to query count reduction
  • Fixed pg_total_relation_size crashing Oxla when provided with invalid literal oid
  • Fixed issue that caused queries to hang when executing a high volume of insert queries in rapid succession
  • STRPOS function is working
  • Fixed out of memory errors crashing Oxla for some queries
  • Faster CSV reader initialization
  • Fix unsynchronized memory access that theoretically could cause improper behavior
  • Fixed a bug, where length(<const value>) function would fail

​
Oxla 1.14.0 - 21/2/24

  • A sanity check on oxla startup for minimal memory.max and memory.non_query_max configuration
  • information_schema.columns, which contain information about all columns in user namespaces
  • pg_language table
  • to_char function converting timestamp/timestamptz to string using given format string
  • Support for int8 and int4 binary parameters in Postgres extended query protocol

​
Oxla 1.13.0 – 16/2/24

  • Add information_schema.referential_constraints table for tools integration purposes
  • Add to_char function to convert the number to string using the given format string
  • Add to_timestamp function to convert the string to timestamp using given format string
  • Cast from time to interval date_trunc function working like Postgres date_trunc
  • DISCARD ALL to reset all session variables
  • Add support for pg_catalog.has_database_privilege() function
  • Possibility to the hardcode leader of the cluster in config
  • Postgres-like tables: pg_enum, pg_range, information_schema.character_sets
  • Enabled optimization, taking advantage of complex expressions in filters
  • Add pg_encoding_to_char and pg_size_pretty functionfunction
  • Add pg_catalog.obj_description function although descriptions are not supported by Oxla, always returns null
  • Add table tables in the information_schema namespace
  • Add table pg_catalog.pg_tablespace , pg_catalog.pg_database , information_schema.key_column_usage, and pg_catalog.pg_am support
  • Support for operator interval div number
  • Reduced the amount of s3 requests when performing COPY FORM (FORMAT CSV)
  • Improved the error messages in INSERT INTO VALUES queries
  • Increased stability of COPY FROM queries with large inputs
  • Fixed the issue with INSERT INTO SELECT queries where data types were not cast to proper types automatically

​
Oxla 1.8.0 - 12/1/24

  • Optimization of HAVING clause when combined with WHERE clause in the same query
  • Support for String Constants with C-Style Escapes
  • Support for COPY (table|select statement) TO filename.csv (options) query
  • Support for operator interval * float
  • Fixed the instability issue when the whole table’s content has been deleted using DELETE FROM <table_name>
  • Fixed the instability cluster issue when disconnecting a disconnected node bug in cluster monitoring
  • Fixed a bug that appeared during conversion intervals when the interval used a date/time format
  • Fixed the error handling response when the pipeline startup failed
  • Fixed a bug with duplicated name detection caused the cluster to be inoperable after startup
  • Fixed a bug on INSERT INTO table SELECT statement due to the lifetime issues

​
2023

​
Oxla 1.4.0 - 14/12/23

  • Support for date - date operator
  • Support for time - time operator
  • Support for date + time operator
  • Improved performance of query planning
  • Fixed intermittent crashes in the GROUP BY
  • Fixed a bug that happens when deleting the index table
  • Fixed the Google Cloud Storage compatibility issue
  • Fixed an issue that could result in a crash when running GROUP BY over columns with very high cardinality
  • Fixed an issue that could result in deadlock upon cluster startup
  • The default AWS S3 endpoint is used when no endpoint is specified in the COPY statement

​
Oxla 1.3.0 - 06/12/23

  • Fixed the degradation error failure when OXLA_HOME was an empty S3 folder created before Oxla started
  • Fixed a bug where OXLA would not return an error when cast would overflow the integer type
  • Fixed a bug where OXLA would return an error when casting values from Date type to Timestamp/Timestamptz
  • Fixed the issue of improper read of storage_config.s3.http parameter
  • Fixed a bug in an optimization causing some queries using aggregation functions as WHERE conditions to fail to plan and run on OXLA
  • The COPY statement with unsupported FORMAT (tbl / binary / bin) will return error (”… format not supported”). Previously all these formats, despite their names, resulted in importing CSV. COPY without provided FORMAT will still use CSV as default format
  • The format of internal messages passed between Oxla nodes for COPY CSV changed, so the new node and old node must not be in the same cluster when COPY is being executed
  • We are working closely with our team to resolve this issue as soon as possible

​
Oxla 1.2.0 - 27/11/23

  • Handling columns specified in the INSERT INTO with SELECT. e.g. INSERT INTO tbl1(c2) SELECT col1 FROM tbl2
  • Extended support for implicit conversions of timestamp-like types in INSERT and COPY queries
  • Fixed the arithmetic operator was used to determine the output type
  • Fixed the errors with storage communication
  • Fixed the error handling when downcasting number types with losing data
  • Fixed the issue that Oxla sometimes left files when dropping tables or deleting data

​
Oxla 1.1.0 - 20/11/23

  • Support for Basic INSERT INTO [table] SELECT [statement]
  • Improved performance of most GROUP BY variants
  • Slight performance improvement of GROUP BY over numeric columns
  • Degraded node stays in the cluster
  • Fixed the issue with the node connection to the cluster
  • Disabled the empty string as a valid internal value
  • Fixed the failures when reading timestamp values from CSV