cassandra: Make sure timestamp is always logged (if set) with debug_queries=y It wasn't logged in some code paths.

cassandra: Fix setting timestamp for transaction queries with v3 protocol It was working for prepared statements, but not for non-prepared statements.

Updated copyright notices to include the year 2018.

cassandra: Fix crash when using prepared statements Broken by cae3c6903c10682429f9849ab1a25093e3f538e4

driver-cassandra: Free statement pool on update Otherwise the pool memory will leak. This was happening with non-prepared statements when version was older than 4.

cassandra: Include the used timestamp in logged queries

cassandra: Rename cassandra_sql_statement.pending_timestamp to just timestamp

cassandra: Support "timestamp" type fields properly Fixes setting them with prepared statements. Reading them never worked earlier.

cassandra: Include "prepared" when logging about prepared statement queries Mainly useful for debugging/testing.

cassandra: Fix using bigint types with unprepared statements This reverts the code to not using the statements with binding at all. Alternative fix would be to start using explicit int32 or int64 parameter types, but that breaks backwards compatibility a bit.

global: Use PRI* macros and %zu instead of casting

global: start relying on pool_unref(NULL) being a no-op Cleanup performed with the following semantic patch: @@ expression E; @@ - if (E != NULL) { - pool_unref(&E); - } + pool_unref(&E);

global: start relying on timeout_remove(NULL) being a no-op Cleanup performed with the following semantic patch: @@ expression E; @@ - if (E != NULL) { - timeout_remove(&E); - } + timeout_remove(&E);

global: start relying on io_remove{,_closed}(NULL) being a no-op Cleanup performed with the following semantic patch: @@ expression E; @@ - if (E != NULL) { - io_remove(&E); - } + io_remove(&E); @@ expression E; @@ - if (E != NULL) { - io_remove_closed(&E); - } + io_remove_closed(&E);

cassandra: Timestamp should be in microseconds, not milliseconds

cassandra: NULL values' sizes weren't initialized This was only a problem if sql_result_get_field_value_binary() was attempted to be used for a NULL value.

cassandra: Fix paged queries to work again When continuing the result, consistency was reset to 0 (=ANY), which caused the queries to fail. There's no need to initialize the statement again when continuing it. Also set result->consistency to be correct mainly for debugging purposes.

cassandra: Disable prepared statements with protocol v3 and older

cassandra: Add support for prepared statements

cassandra: Cleanup - Create statement earlier Simplifies the following changes

cassandra: sql_transaction_commit*() cleanup - handle multiple query failures earlier This makes the handling same for the sync and async method. It also simplifies code for the following commits.

cassandra: sql_transaction_commit_s() - Set query_type correctly The queries were all sent with READ type instead of WRITE/DELETE. This meant they were using potentially wrong consistency values. Although synchronous commits aren't actually used anywhere, so this practically this doesn't fix anything right now.

cassandra: sql_transaction_commit_s() - Don't allow multi-query transactions They were already denied for asynchronous commits. Also the synchronous commits aren't actually used anywhere, so this shouldn't break anything.

lib-sql: Explicitly specify used *_vfuncs methods for drivers. This allows adding more methods without modifying all the existing drivers.

cassandra: Fix confusing debug logging for paged query results. Even when caller supported paged queries, the debug output contained "Paged query has more results, but not supported by the caller". Clear out the error after sql_result_more() is called, so it won't be logged.

lib-sql: Remove duplicate Cassandra consistency names

cassandra: Fix read/write buffer overflows after adding CASSANDRA_QUERY_TYPE_READ_MORE

cassandra: Improve logging for multipage queries warn_timeout is applied to both individual page requests as well as the sum of all the page requests.

cassandra: Add page_size setting to enable paged results for queries

cassandra: Add wrapper functions in preparation for following commits No functional changes. Shrinks the following commits.

lib-sql: Add API support for asynchronously iterating over rows. sql_query() can already do an async lookup, but the full result needs to be available immediately. This can be inefficient for large results. Add a new SQL_RESULT_NEXT_MORE return value and sql_result_more() for asynchronously requesting more results. This changes the API a bit, but isn't done by default by any drivers yet. Also callers that can't handle this are hopefully checking for "ret < 0", which allows them to handle such an async-more request as an error instead. sql_result_next_row() will be changed to return enum in a separate commit to keep backwards compatibility in v2.2.x.

cassandra: Use fallback consistency for CASS_ERROR_LIB_NO_HOSTS_AVAILABLE errors I'm not entirely sure if this is always appropriate, but at least this error happens every time when attempting to use write_consistency=two when there is only a single Cassandra node.

driver-cassandra: Add metric for slow queries

cassandra: Fallback consistency fix - it wasn't used permanently Because the "do I want to retry using primary consistency?" check was done using the first failure timestamp, after 60 seconds that check always returned TRUE. We should instead be checking the last timestamp for a query that was sent with the primary consistency.

cassandra: Fallback consistency fix - max retry interval was set wrong The maximum msecs is _MAX_RETRY_MSECS, not _FIRST_RETRY_MSECS

cassandra: Treat CASS_ERROR_SERVER_UNAVAILABLE as "write success is uncertain" Looks like the write could still have actually gone through.

cassandra: Don't use i_error() from non-main thread It will only cause crashes. This was done only if the internal communication pipe couldn't be written to, which was pretty unlikely to happen.

driver-cassandra: Add support for speculative execution

cassandra: Track query counts internally and include them in metrics

cassandra: Support configuring heartbeat_interval and idle_timeout

cassandra: Add support for "bigint" value type.

Updated copyright notices to include the year 2017.

global: Replaced all instances of memset(p, 0, sizeof(*p)) with the new i_zero() macro. Used the following script: C_FILES=`git ls-files *.c` H_FILES=`git ls-files *.h` for F in "$C_FILES $H_FILES"; do echo "$F" perl -p -i -e 's/safe_memset\(&\(?([^,]*)\)?,\s*0,\s*sizeof\(\g1\)\)/i_zero_safe(&$1)/g' $F perl -p -i -e 's/safe_memset\(([^,]*),\s*0,\s*sizeof\(\*\g1\)\)/i_zero_safe($1)/g' $F perl -p -i -e 's/memset\(&\(?([^,]*)\)?,\s*0,\s*sizeof\(\g1\)\)/i_zero(&$1)/g' $F perl -p -i -e 's/memset\(([^,]*),\s*0,\s*sizeof\(\*\g1\)\)/i_zero($1)/g' $F done

cassandra: Treat "Request timed out" also as SQL_RESULT_ERROR_TYPE_WRITE_UNCERTAIN CASS_ERROR_SERVER_WRITE_TIMEOUT is "Write timeout" as reported by Cassandra server, while CASS_ERROR_LIB_REQUEST_TIMED_OUT is timeout as reported by the Cassandra library.

lib: API change - var_expand*() now returns error string. This allows callers to fail properly if the format string is invalid.

Compiler warning fixes with -Wstrict-bool

cassandra: Added latency_aware_routing connect-parameter. There's currently no way to change the default settings for it.

lib-sql: Added error_type to commit callback.

cassandra: Support returning SQL_RESULT_ERROR_TYPE_WRITE_UNCERTAIN

cassandra: Added debug_queries connect setting. This logs all the queries and how long they took, without having to log all the other Cassandra library debug messages.

cassandra: If query fails, include how long the reply took in the error message.

cassandra: Warn if queries take too long (default 5 secs) Can be changed with e.g. "connect = ... warn_timeout=30s"

cassandra: Try fallback_consistency also for write timeout failures.

global: Require comparisons to be strict boolean expressions * No implicit integer -> boolean or pointer -> boolean conversions * !expr can be used only if expr is boolean type These were checked with a patched clang. It found various actual bugs, which were fixed by the previous commits.

global: unsigned int:1 -> bool:1 perl -i -pe 's/unsigned int ([^,:;]+):1;/bool $1:1;/' **/*.[ch]

cassandra: Added metrics=path connect setting. Cassandra's metrics are written to the path in JSON format. It can be a file or a FIFO. The path supports expanding the standard global %variables, such as %{pid}

cassandra: Support milliseconds for request/connect_timeout

cassandra: Added num_threads, connect_timeout and request_timeout settings.

cassandra: Added support for user and password settings.

lib-sql: Allow port to be configured for Cassandra cluster

global: freshen copyright git ls-files | xargs perl -p -i -e 's/(\d+)-201[0-5]/$1-2016/g;s/ (201[0-5]) Dovecot/ $1-2016 Dovecot/'

cassandra: Added read/write/delete_fallback_consistency settings. The fallback is attempted if the primary consistency can't be satisfied. One useful use case for this is to have: write_consistency=each-quorum write_fallback_consistency=local-quorum Which means that during regular operation all writes go to all data centers before they are finished, but if one of the data centers go down we'll switch to just waiting for local data center writes to finish.

cassandra: Added support for returning "int" type values. It looks like we need to explicitly convert all types to strings.

cassandra: copy&paste mistake - use monotonic timestamp generator, not server side..

cassandra: Added "version" parameter to specify a protocol version. Mainly to avoid warnings logged when connecting to an older Cassandra server.

cassandra: Use a local monotonic timestamp generator. Otherwise we run into race conditions on server side timestamps, which cause problems.

cassandra: With debugging, log also how many rows were iterated.

cassandra: With debugging, log also how long result was used for before it was freed. This includes the time spent on SELECT query's iterator.

cassandra: Don't crash if connection to Cassandra failed.

cassandra: If log_level=debug, log also how long the queries take.

cassandra: Added delete_consistency parameter.

cassandra: Handle async queries internally - don't use sql pooling code. There's no need to create multiple Cassandra instances, since the single instance is capable of doing multiple asynchronous requests in parallel.

lib-sql: Implemented sql_escape_blob()

cassandra: Implemented support for binary values.

lib-sql: Mark Cassandra driver as pooled. Otherwise all the asynchronous operations will assert-crash, since all the auto-connecting code is in the sqlpool code.

lib-sql: Debugging help - Added assert before clearing sql_result.callback. If result is unrefed too many times, this still allows accessing the callback from a debugger.

lib-sql: sql_result.free() should never be reached from the query callback. This code was probably added before sql_result refcounting.

cassandra: Changed default consistency levels to local-quorum. It is a much safer default than "one".

cassandra: Split consistency setting to read_consistency and write_consistency.

cassandra: Commit failures returned an already freed error string.

cassandra: Error handling cleanup. Probably doesn't fix any actual bugs.

cassandra: Minor code cleanup to make sure we don't try to access freed transaction memory.

cassandra: Don't access freed memory when doing an assert-check.

cassandra: If log_level=debug/trace, log each query and its result.

cassandra: Added extra asserts and sanity checks to make sure query errors are caught.

cassandra: Don't crash on failed queries.

cassandra: Added log_level parameter to connect_string. Available values are critical, error, warn (default), info, debug and trace.

cassandra: Leave consistency to default if it's not specified in config.

lib-sql: Don't crash in Cassandra if connection to it failed.

lib-sql: Added support for Cassandra CQL as lib-sql backend. Implemented using DataStax's cpp-driver. Many things are still unimplemented. Column name specific functionality isn't even supported by the Cassandra library. So this can currently mainly be used as one of the dict backends for some simple functionality.