Reorder sqlite_query params: query_type before query (match Node.js/.NET)

All SDKs now use (queryType, query, params) parameter order, consistent
with the Node.js and .NET reference implementations.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SteveSandersonMS

go/internal/e2e/session_fs_sqlite_e2e_test.go

@@ -195,7 +195,7 @@ func (p *inMemorySqliteProvider) Rename(src string, dest string) error {
 	return nil
 }
 
-func (p *inMemorySqliteProvider) SqliteQuery(query string, queryType rpc.SessionFsSqliteQueryType, params map[string]any) (*copilot.SessionFsSqliteQueryResult, error) {
+func (p *inMemorySqliteProvider) SqliteQuery(queryType rpc.SessionFsSqliteQueryType, query string, params map[string]any) (*copilot.SessionFsSqliteQueryResult, error) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 	p.hadQuery = true

go/session_fs_provider.go

@@ -57,7 +57,7 @@ type SessionFsProvider interface {
 // so these methods do not take a session ID parameter.
 type SessionFsSqliteProvider interface {
 	// SqliteQuery executes a SQLite query against the provider's per-session database.
-	SqliteQuery(query string, queryType rpc.SessionFsSqliteQueryType, params map[string]any) (*SessionFsSqliteQueryResult, error)
+	SqliteQuery(queryType rpc.SessionFsSqliteQueryType, query string, params map[string]any) (*SessionFsSqliteQueryResult, error)
 	// SqliteExists checks whether the provider has a SQLite database for the session.
 	SqliteExists() (bool, error)
 }
@@ -201,7 +201,7 @@ func (a *sessionFsAdapter) SqliteQuery(request *rpc.SessionFsSqliteQueryRequest)
 			Error:        &rpc.SessionFsError{Code: rpc.SessionFsErrorCodeUNKNOWN, Message: &msg},
 		}, nil
 	}
-	result, err := sp.SqliteQuery(request.Query, request.QueryType, request.Params)
+	result, err := sp.SqliteQuery(request.QueryType, request.Query, request.Params)
 	if err != nil {
 		return &rpc.SessionFsSqliteQueryResult{
 			Columns:      []string{},

python/copilot/session_fs_provider.py

@@ -120,8 +120,8 @@ class MyProvider(SessionFsProvider, SessionFsSqliteProvider): ...
     @abc.abstractmethod
     async def sqlite_query(
         self,
-        query: str,
         query_type: SessionFSSqliteQueryType,
+        query: str,
         params: dict[str, float | str | None] | None = None,
     ) -> SessionFsSqliteQueryResult:
         """Execute a SQLite query against the provider's per-session database."""
@@ -273,8 +273,8 @@ async def sqlite_query(self, params: Any) -> _GeneratedSqliteQueryResult:
                 ),
             )
         result = await self._p.sqlite_query(
-            params.query,
             params.query_type,
+            params.query,
             getattr(params, "params", None),
         )
         return _GeneratedSqliteQueryResult(

python/e2e/test_session_fs_sqlite_e2e.py

@@ -148,8 +148,8 @@ async def rename(self, src: str, dest: str) -> None:
 
     async def sqlite_query(
         self,
-        query: str,
         query_type: SessionFSSqliteQueryType,
+        query: str,
         params: dict[str, float | str | None] | None = None,
     ) -> SessionFsSqliteQueryResult:
         self._sqlite_calls.append(

rust/src/session_fs.rs

@@ -410,8 +410,8 @@ pub trait SessionFsSqliteProvider: Send + Sync {
     /// Execute a SQLite query against the provider's per-session database.
     async fn sqlite_query(
         &self,
-        query: &str,
         query_type: SessionFsSqliteQueryType,
+        query: &str,
         params: Option<&HashMap<String, serde_json::Value>>,
     ) -> Result<SessionFsSqliteQueryResult, FsError>;
 

rust/src/session_fs_dispatch.rs

@@ -342,8 +342,8 @@ pub(crate) async fn sqlite_query(
     let sqlite_params = (!params.params.is_empty()).then_some(&params.params);
     let result = match sqlite
         .sqlite_query(
-            &params.query,
             params.query_type,
+            &params.query,
             sqlite_params,
         )
         .await

rust/tests/e2e/session_fs_sqlite.rs

@@ -211,8 +211,8 @@ impl SessionFsProvider for InMemorySqliteProvider {
 impl SessionFsSqliteProvider for InMemorySqliteProvider {
     async fn sqlite_query(
         &self,
-        query: &str,
         query_type: SessionFsSqliteQueryType,
+        query: &str,
         _params: Option<&HashMap<String, serde_json::Value>>,
     ) -> Result<SessionFsSqliteQueryResult, FsError> {
         let qt_str = match query_type {

rust/tests/session_test.rs

@@ -2994,8 +2994,8 @@ impl SessionFsProvider for RecordingFsProvider {
 impl SessionFsSqliteProvider for RecordingFsProvider {
     async fn sqlite_query(
         &self,
-        query: &str,
         query_type: SessionFsSqliteQueryType,
+        query: &str,
         params: Option<&std::collections::HashMap<String, serde_json::Value>>,
     ) -> Result<SessionFsSqliteQueryResult, FsError> {
         let mut row = std::collections::HashMap::new();
@@ -3220,8 +3220,8 @@ async fn session_fs_maps_sqlite_errors_to_results() {
     impl SessionFsSqliteProvider for AlwaysFails {
         async fn sqlite_query(
             &self,
-            _query: &str,
             _query_type: SessionFsSqliteQueryType,
+            _query: &str,
             _params: Option<&std::collections::HashMap<String, serde_json::Value>>,
         ) -> Result<SessionFsSqliteQueryResult, FsError> {
             Err(FsError::Other("sqlite unavailable".to_string()))