Estou experimentando usar o ADO para conectar um frontend do Access a um backend do Access. O frontend é apenas uma ferramenta de entrada de dados. Os usuários não farão edições/atualizações em nenhum registro no backend. O motivo para fazer isso é que mais de 255 usuários usarão o frontend simultaneamente, então tabelas vinculadas normais com conexão persistente ao backend não funcionarão (sei que essa configuração parece ilógica; por favor, evite dizer que eu não deveria usar o Access para o backend).

Consegui fazer funcionar para algumas coisas. Uma Insertinstrução SQL curta funciona como esperado, mas uma Insertinstrução mais longa (11 colunas no meu caso) resulta em um erro:

Erro de tempo de execução '-2147217900 (80040e14)': erro de sintaxe na instrução INSERT INTO

Veja como o código se parece:

Public Const ConnectionStr As String = "Provider=Microsoft.ACE.OLEDB.16.0;Data Source=\\[Network]\[Folder]\[File].accdb"
Dim conn As New ADODB.Connection, SQLstr as String

conn.Open ConnectionStr
SQLstr = "INSERT INTO [mytable](field1, field2, [...], field11) values(1, 2, [...], 11)"

Debug.Print SQLstr
conn.Execute SQLstr
conn.Close

Os valores na insertinstrução são todos obtidos de controles no frontend, então há muita concatenação de strings, mas esse não é o problema. Copiei a debug.printsaída da janela imediata, colei na janela de consulta do Access, executei e o registro foi inserido sem problemas.

(Eu também estava recebendo "erro de sintaxe na cláusula FROM" ao fazer uma consulta select com uma cláusula where, mas não consigo replicar isso agora)

Então, qual é o motivo desse erro e existe uma maneira de corrigi-lo? Existe um limite de tamanho de texto para strings SQL executadas com conexões ADO? Acho que isso não faria sentido... Mas testei reduzir o número de campos na instrução insert para 9 e funcionou.

Minha solução alternativa é apenas usar o DAO, criando uma tabela vinculada temporária ao backend, executando a insertinstrução e, em seguida, excluindo a tabela vinculada

Imagem adicionada em resposta à resposta de Jonathan abaixo: captura de tela do VBE

Eu tenho o seguinte código de ferrugem

use std::any::Any;
use std::rc::Rc;

fn main() {
    let mut variables = Vec::<Rc<dyn Any>>::new();
    variables.push(Rc::new(1_i32));
    variables.push(Rc::new(false));
    variables.push(Rc::new(4.53_f64));

    let integer: i32 = *variables[0].clone().downcast::<i32>().unwrap();
    let boolean: bool = *variables[1].clone().downcast::<bool>().unwrap();
    let floating: f64 = *variables[2].clone().downcast::<f64>().unwrap();

    let my_goal: (i32, bool, f64) = (integer, boolean, floating)

    println!("{:?}", my_goal);

que eu quero automatizar usando uma macro. ( Eu sei que isso não é o ideal, mas isso é apenas um MWE para fazer uma pergunta sobre macros )

Em particular, quero criar uma tupla que faça downcasting Anypara tipos fornecidos

Minha primeira tentativa é:

macro_rules! my_macro {
    ($vector:ident; $($type:ty),*) => {
        // ($($type),*)
        //println!("{:?}", $vector);
        //$(println!("{:?}", stringify!($type));)*
        let idx = 0;
        ($(
                *$vector[0].clone().downcast::<$type>().unwrap()
        ),*)
    };
}

que está errado por causa do 0hardcoded. Eu tentei várias maneiras de declarar uma variável e incrementá-la ao longo da macro, mas elas falharam. Como posso fazer?

Estou usando a versão mais recente do Next.js (com o App Router e o TypeScript) e notei que meu projeto usa um arquivo postcss.config.mjs em vez do postcss.config.js usual.

Quero adicionar cores personalizadas à minha configuração Tailwind CSS, mas não tenho certeza de como configurá-lo corretamente nesta configuração. Preciso modificar postcss.config.mjs para adicionar cores personalizadas? Ou há um arquivo diferente que eu deva usar?

Em libstdc++ há o seguinte código:

  class common_iterator
  {
...
    [[nodiscard]]
    constexpr decltype(auto)
    operator*()
    {
      __glibcxx_assert(_M_index == 0);
      return *_M_it;
    }

    [[nodiscard]]
    constexpr decltype(auto)
    operator*() const requires __detail::__dereferenceable<const _It>
    {
      __glibcxx_assert(_M_index == 0);
      return *_M_it;
    }
...
}

Estou tentando entender por que não temos apenas um operator*() constmembro. Quando tenho uma referência const para um iterador (não const_iterator), acho que é natural permitir a desreferência, mas esta fonte sugere que às vezes não consigo desreferenciar tais referências const.

Por que e em quais casos faz sentido proibir a desreferenciação?

Estou trabalhando em uma aplicação que interage com um PostgreSQL usando drizzle-orm e estou com problemas para atualizar a contagem de mensagens de um usuário no perfil dele. A updateProfilefunção deveria incrementar o messageCountcampo, mas não parece estar atualizando como esperado.

export async function getProfile(userId: string): Promise<Array<Profile>> {
  try {
    return await db.select().from(profile).where(eq(profile.userId, userId));
  } catch (error) {
    console.error("Failed to get the profile from database");
    throw error;
  }
}

export async function updateProfile(userId: string, updates: Partial<Profile>) {
  try {
    return await db.update(profile).set(updates).where(eq(profile.userId, userId));
  } catch (error) {
    console.error("Failed to update the profile");
    throw error;
  }
}

export const profile = pgTable("Profile", {
  id: uuid('id').primaryKey().notNull().defaultRandom(),
  userId: uuid('userId')
    .unique()
    .references(() => user.id, { onDelete: "cascade" }),
  trialDuration: integer("trialDuration").default(1 * 60), // seconds
  trialEndTime: timestamp("trialEndTime"),
  messageCount: integer("messageCount").notNull().default(0),
  createdAt: timestamp('createdAt').defaultNow(),
});

export type Profile = InferSelectModel<typeof profile>;

const [profile] = await getProfile(session.user.id)
let messageCount = profile.messageCount;

if (messageCount < MAX_MESSAGES) {
  console.log("Old profile: ", profile);
  console.log("Test", session.user.id)
  const newProfile = await updateProfile(session.user.id, { messageCount: messageCount++})
  console.log("New profile: ", profile);
} 

O que eu fiz:

1. Registrei as atualizações dos argumentos do updateProfile, a saída foi { messageCount: 0}, sempre, então não houve incremento.
2. Registrei o valor de prevCountantes da atualização para garantir que está correto.
3. Tentei usar prevCount + 1diretamente na updateProfilechamada, mas também não funcionou.

Saída:

Old profile:  {
  id: '60862459-56b3-4279-a872-c406e870b873',
  userId: 'a6b9ca00-2935-4b06-bd80-35e81b89ef3c',
  trialDuration: 60,
  trialEndTime: null,
  messageCount: 0,
  createdAt: 2025-04-06T05:52:54.838Z
}
Test a6b9ca00-2935-4b06-bd80-35e81b89ef3c
New profile:  {
  id: '60862459-56b3-4279-a872-c406e870b873',
  userId: 'a6b9ca00-2935-4b06-bd80-35e81b89ef3c',
  trialDuration: 60,
  trialEndTime: null,
  messageCount: 0,
  createdAt: 2025-04-06T05:52:54.838Z
}

ATUALIZAR

Funciona se eu passar o perfil como argumento

  const [profile] = await getProfile(session.user.id);
  console.log(profile);
  
  if (profile.messageCount < MAX_MESSAGES) {
    profile.messageCount++;
    await updateProfile(session.user.id, profile);
  } 

Mas não é isso que eu quero, eu quero atualizar os valores que eu especifico.

esta é a primeira vez que faço uma pergunta aqui, então, por favor, tenham paciência se eu esquecer de alguma coisa.

Criei um projeto bancário simples no Spring Boot com as seguintes APIs REST:

/criar

/obterConta

/depósito

/retirar

/deleteConta

Tudo funciona perfeitamente:

1. As APIs funcionam corretamente e atualizam o banco de dados conforme o esperado
2. A interface do usuário do Swagger mostra todos os endpoints conforme pretendido
3. Os testes do Postman também funcionam sem problemas

Entretanto, quando adicionei tratamento de exceção personalizado usando @ControllerAdvice, o Swagger começou a gerar este erro:

Falha ao carregar a definição da API. O status da resposta é 500 /v3/api-docs

Aqui está a parte estranha: quando eu removo as classes de exceção, o Swagger começa a funcionar novamente! Então, claramente, há algo na configuração de tratamento de exceção que está causando esse problema.

Alguém pode me ajudar a descobrir o que está errado?

Classe ErrorResponse:

package com.bank.bankingApplication.exceptions;

import java.time.LocalDateTime;

public class ErrorResponse {
    private String message;
    private String timestamp;
    private String path;

    public ErrorResponse(String message, String path) {
        this.message = message;
        this.timestamp = LocalDateTime.now().toString();
        this.path = path;
    }

    // Getters and Setters

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(String timestamp) {
        this.timestamp = timestamp;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }
}

Classe GlobalExceptionHandler:

package com.bank.bankingApplication.exceptions;


import com.bank.bankingApplication.controller.BankController;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;


@ControllerAdvice
@RestControllerAdvice(assignableTypes = {BankController.class})
public class GlobalExceptionHandler {

//    @ExceptionHandler(Exception.class)
//    public ResponseEntity<ErrorResponse> handleAllExceptions(Exception ex, HttpServletRequest request) {
//        ErrorResponse error = new ErrorResponse(ex.getMessage(), request.getRequestURI());
//        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
//    }

    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    public ResponseEntity<ErrorResponse> handleTypeMismatch(MethodArgumentTypeMismatchException ex, HttpServletRequest request) {
        String msg = "Invalid type for parameter: " + ex.getName();
        ErrorResponse error = new ErrorResponse(msg, request.getRequestURI());
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ErrorResponse> handleIllegalArgs(IllegalArgumentException ex, HttpServletRequest request) {
        ErrorResponse error = new ErrorResponse(ex.getMessage(), request.getRequestURI());
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    // You can add more specific ones like @ExceptionHandler(AccountNotFoundException.class) here.
}

Controlador:

package com.bank.bankingApplication.controller;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import com.bank.bankingApplication.model.Account;
import com.bank.bankingApplication.repository.AccountRepository;
import com.bank.bankingApplication.service.AccountService;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;

@RestController
@RequestMapping("/bank")
@Tag(name = "Bank Controller", description = "Handles operations related to bank accounts")
public class BankController {
    @Autowired
    private AccountService accountService;

    @Autowired
    private AccountRepository accountRepository;

    @Operation(
            summary = "Create a new bank account",
            description = "This endpoint is used to create a new bank account for a user."
    )
    @PostMapping("/create")
    public Account createAccount(@RequestBody Account account){
        return accountService.createAccount(account);
    }

    @Operation(
            summary = "Fetches the existing bank account",
            description = "This endpoint is used to fetch an existing bank account for a user."
    )
    @PostMapping("/getAccount")
    public ResponseEntity<?> getAccountDetails(@RequestBody Account account) {
        Long id = account.getId();
        Optional<Account> accountOpt = accountRepository.findById(id);
        if (accountOpt.isPresent()) {
            return ResponseEntity.ok(accountOpt.get());
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Account not found");
        }
    }

    @Operation(
            summary = "Deposits the amount",
            description = "This endpoint is used to deposit amount for a user."
    )
    @PostMapping("/deposit")
    public ResponseEntity<DepositAndWithdrawResponse> deposit(@RequestBody DepositAndWithdrawRequest request) {
        Optional<Account> optionalAccount = accountRepository.findById(request.getId());
        if (optionalAccount.isPresent()) {
            Account account = optionalAccount.get();
            account.setBalance(account.getBalance() + request.getAmount());
            accountRepository.save(account);
            DepositAndWithdrawResponse response = new DepositAndWithdrawResponse();
            response.setId(account.getId());
            response.setAccountHolder(account.getAccountHolder());
            response.setBalance(account.getBalance());
            response.setRemarks("Deposit successful. New balance: " + account.getBalance());
            return ResponseEntity.ok(response);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @Operation(
            summary = "withdraws the amount",
            description = "This endpoint is used to withdraw amount for a user."
    )
    @PostMapping("/withdraw")
    public ResponseEntity<DepositAndWithdrawResponse> withdraw(@RequestBody DepositAndWithdrawRequest request) {
        Optional<Account> optionalAccount = accountRepository.findById(request.getId());
        if (optionalAccount.isPresent()) {
            Account account = optionalAccount.get();
            if(account.getBalance() >= request.getAmount()){
                account.setBalance(account.getBalance() - request.getAmount());
                accountRepository.save(account);
                DepositAndWithdrawResponse response = new DepositAndWithdrawResponse();
                response.setId(account.getId());
                response.setAccountHolder(account.getAccountHolder());
                response.setBalance(account.getBalance());
                response.setRemarks("Withdraw successful. New balance: " + account.getBalance());
                return ResponseEntity.ok(response);
            }
            else{
                account.setBalance(account.getBalance());
                accountRepository.save(account);
                DepositAndWithdrawResponse response = new DepositAndWithdrawResponse();
                response.setId(account.getId());
                response.setAccountHolder(account.getAccountHolder());
                response.setBalance(account.getBalance());
                response.setRemarks("Withdraw unsuccessful because entered amount was greater than the current balance: " + account.getBalance());
                return ResponseEntity.ok(response);
            }

        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @DeleteMapping("/deleteAccount")
    @Operation(
            summary = "Deletes an existing bank account",
            description = "This endpoint is used to delete an existing bank account for a user."
    )
    public ResponseEntity<String> deleteAccountById(@RequestBody Map<String, Long> request) {
        Long id = request.get("id");
        Optional<Account> account = accountRepository.findById(id);
        if (account.isPresent()) {
            accountRepository.deleteById(id);
            return ResponseEntity.ok("Account with ID " + id + " has been deleted successfully.");
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Account with ID " + id + " not found.");
        }
    }

}

propriedades do aplicativo:

spring.datasource.url=jdbc:mysql://localhost:3306/bank
spring.datasource.username=root
spring.datasource.password=MyPassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.database-platform=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<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.4.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.bank</groupId>
    <artifactId>bankingApplication</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>bankingApplication</name>
    <description>Demo project for Spring Boot</description>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>21</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>2.3.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Adicionei @ControllerAdvice com classes de exceção personalizadas para retornar respostas de erro estruturadas. Eu esperava que o Swagger continuasse funcionando como antes, mas, em vez disso, recebi um erro 500 em /v3/api-docs. Remover o manipulador de exceção corrige o Swagger, então acredito que algo está errado dentro da camada de tratamento de exceção. Para solucionar o problema, comentei o @ExceptionHandler(Exception.class) generalizado e mantive apenas os específicos, como MethodArgumentTypeMismatchException e IllegalArgumentException, supondo que o Swagger possa depender de algum tratamento de exceção integrado. Mas o resultado ainda foi o mesmo — o Swagger falha ao carregar com um erro 500, enquanto o Postman funciona bem.

Tenho um problema, quero fazer alterações em uma tabela de banco de dados de um determinado usuário. Consegui fazer isso abrindo outra página.

<td><a href="includes/update.php?id=<? echo $user['id']?>" class="edit">Edit href</a></td>

A página será aberta da seguinte forma código da página img

Mas pela janela modal, quando tento abrir os dados, recebo uma mensagem de erro: Aviso: Chave de array indefinida "id" em C:\Program Files\Ampps\www\admin\index.php na linha 182

                <td><button tupe="hidden" name="user_id" onclick="window.myDialog.showModal()" value="<? echo $user['id']?>" class="regbtn">Edit modal</button></td>
            </tr>
            <?
        }
        ?>
        </tbody>
        </table>
                    <div class="left">
                        <dialog id="myDialog" class="modal">
                            <div class="reg-form">
                                <h6>Change the data</h6>
                                <button onclick="closeDialog()">x</button>
                                <script>
                                    var x = document.getElementById("myDialog"); 
                                    function showDialog() { 
                                    x.show(); 
                                    } 
                                    function closeDialog() { 
                                    x.close(); 
                                    } 
                                </script>
                                <form method="POST">
                                    <?
                                        $id = $_GET['id'];
                                        $query = mysqli_query($connect, query: "SELECT * from `users` where ID='$id'");
                                        while($row = mysqli_fetch_array($query)) {
                                    ?>
                                    <div class="reg-box">
                                        <input type="text" value="<? echo $row["lastname"]?>" name="lastname" placeholder="Last Name">
                                    </div>
                                    <div class="reg-box">
                                        <input type="text" value="<? echo $row["name"]?>" name="name" placeholder="Name">
                                    </div>
                                    <div class="reg-box">
                                        <input type="text" value="<? echo $row["fathername"]?>" name="fathername" placeholder="Father Name">
                                    </div>
                                    <div class="reg-box">
                                        <input type="number" value="<? echo $row["code"]?>" name="code" placeholder="Code">
                                    </div>
                                    <div class="reg-box">
                                        <input type="text" value="<? echo $row["username"]?>" name="username" placeholder="Login">
                                    </div>
                                    <div class="reg-box">
                                        <input type="number" value="<? echo $row["password"]?>" name="password" placeholder="Password">
                                    </div>
                                    <? } ?>    
                                    <button tupe="reg" class="btn">Edit</button>
                                </form>
                            </div>
                            <style type="text/css">
                                dialog {
                                    margin-inline: auto;
                                    margin-block-start: 120px;
                                    background: transparent;
                                    box-shadow: 0 0 10px rgba(0, 0, 0, 0.211);
                                    border: none;
                                    border-radius: 1rem;
                                }
                                dialog::backdrop {
                                    background-color: rgba(0, 0, 0, 0.2);
                                }
                            </style>
                        </dialog>
                    </div>
    </div>

Com classes normais você tem **kwargsargumentos __init__de palavras-chave não correspondentes que podem ser ignorados:

class MyClass:
    def __init__(self, a, **kwargs):
        self.a=a

my_class = MyClass(20, **{"kwarg1" : 1})

Existe um equivalente @dataclassque pode ignorar facilmente argumentos de palavras-chave não correspondentes sem precisar incluir um __init__?

from dataclasses import dataclass

@dataclass
class MyClass:
    a: int

my_class = MyClass(20, **{"kwarg1" : 1}) # TypeError: MyClass.__init__() got an unexpected keyword argument 'kwarg1'

No caso abaixo, onde um pai deve ser extraído de uma string por meio de uma expressão regular

input_string = "02150 ESPOO"
input_string[pattern]

Dois resultados muito diferentes surgem quer a patternexpressão regular seja delimitada (começando e terminando) /^\d{5}$/ou não/\d{5}/

Eu obtenho o resultado desejado no último caso, enquanto o primeiro retorna nil. Por que o regex bookened falha?

Quando meu código não tem um namespace, posso usar o "usings quickfix" ( ctrl + .) para recomendar namespaces aplicáveis.

Eu uso uma biblioteca que possui muitos tipos com nomes idênticos aos do framework e até mesmo aos do meu próprio código. Portanto, o quickfix frequentemente recomenda namespaces dessa biblioteca e os coloca primeiro no pop-up.

Posso configurar o roslyn para ignorar determinados namespaces ao usar o quickfix?