All perguntas(coding)

Estou trabalhando em um sistema de rastreamento de localização usando SQL Server, e armazeno atualizações de localização para funcionários a cada poucos segundos. Aqui está minha tabela:

CREATE TABLE tblAppLocation 
(
    id INT PRIMARY KEY IDENTITY(1,1),
    inEmpId INT FOREIGN KEY REFERENCES tblMstEmployee(inEmpId),
    latitude FLOAT NOT NULL,
    longitude FLOAT NOT NULL,
    timestamp DATETIME NOT NULL DEFAULT GETDATE()
);

Nós monitoramos mais de 300 funcionários, inserindo dados 12 horas por dia. Com o tempo, o tamanho da tabela crescerá significativamente.

Minhas preocupações:

• Será que os id INT IDENTITY(1,1)valores acabarão? Devo mudar para BIGINT?

• Há riscos de desempenho com inserções frequentes? Indexação ou particionamento ajudariam?

• Quais são as práticas recomendadas para gerenciar grandes dados de rastreamento de localização no SQL Server?

Quaisquer informações sobre otimização de banco de dados e soluções de armazenamento de longo prazo seriam apreciadas.

O que significam os números entre chaves após o tipo de código no markdown (github)? Não consegui encontrar nenhum documento sobre isso

    ```js{6, 15}
    export default {
      setup() {
        const input = ref(null)
        // ...
        return {
          input
        }
      }
    }
    ```

Encontrei em vários documentos em frameworks de frontend

Meu objetivo é criar um carregador YAML que possa construir mapeamentos de escalares marcados. Aqui está uma versão simplificada do carregador que constrói um objeto contendo nomes de um escalar marcado !fullname.

import ruamel.yaml

class MyLoader(ruamel.yaml.YAML):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.constructor.add_constructor("!fullname", self._fullname_constructor)

    @staticmethod
    def _fullname_constructor(constructor, node):
        value = constructor.construct_scalar(node)
        first, *middle, last = value.split()
        return {
            "first_name": first,
            "middle_names": middle,
            "last_name": last

        }

myyaml = MyLoader()

O carregador pode substituir com sucesso objetos por escalares marcados, ou seja

>>> myyaml.load("""
    - !fullname Albus Percival Wulfric Brian Dumbledore
    - !fullname Severus Snape""")
[
  {'first_name': 'Albus', 'middle_names': ['Percival', 'Wulfric', 'Brian'], 'last_name': 'Dumbledore'},
  {'first_name': 'Severus', 'middle_names': [], 'last_name': 'Snape'}
]

No entanto, a construção falha quando tento mesclar o mapeamento construído em um objeto envolvente

>>> yaml.load("""
    id: 0
    <<: !fullname Albus Percival Wulfric Brian Dumbledore""")
ruamel.yaml.constructor.ConstructorError: while constructing a mapping (...)
expected a mapping or list of mappings for merging, but found scalar

Meu entendimento é que o tipo do nó ainda é um ScalarNode, então o construtor não consegue processá-lo, mesmo que ele acabe resolvendo para um mapeamento. Como modificar meu código, de modo que ele !fullname {scalar}possa ser mesclado ao objeto?

Tenho um Servidor Virtual Dedicado baseado no Ubuntu 20.04.6 com endereço IP 193.23.xxx.xx . blizcore.funresolve para este IP. Neste servidor, instalei o painel pterodactyl. O Pterodactyl tem IP 172.18.0.0/16 . Eu instalo o basic python 3.10 egg no pterodactyl e crio o servidor para a porta 6668 .

Meu alvo: criar uma solicitação GET para https://blizcore.fun/status. Essa solicitação deve ser manipulada pelo servidor Flask em execução no ambiente Pterodactyl.

Código:

from flask import Flask, request
from flask_restful import Api, Resource, abort

from dotenv import load_dotenv
load_dotenv()
import os

key = os.getenv("AUTH_KEY")

app = Flask(__name__)
api = Api()

class BlizcoreApi(Resource):
    def get(self):
        headers = request.headers
        auth = headers.get("Authorization")
        if auth == key:
            return {"code": 200, "message": "All working stable."}
        else:
            return abort(401, message="Unauthorized.")
    

api.add_resource(BlizcoreApi, "/status")
api.init_app(app)

if __name__ == "__main__":
    app.run(host="193.23.220.14", port=6668, debug=True)

Mas tenho erro (saída do console do servidor na porta 6668):

 * Serving Flask app 'server'
 * Debug mode: on
Cannot assign requested address

Tentei conectar o Flask ao host 0.0.0.0para escutar em todas as interfaces e estou conectado ao IP do Pterodactyl (saída do console após essas ações):

* Serving Flask app 'server'
 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:6668
 * Running on http://172.18.0.6:6668
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 144-915-975

As regras do Firewall são assim:

root@vm25-lendnodes:~# sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
22                         ALLOW       Anywhere                  
80                         ALLOW       Anywhere                  
443                        ALLOW       Anywhere                  
...
6668                       ALLOW       172.18.0.0/24
...

Acho que preciso criar um roteador para conectar o fluxo de 172.18.0.6:6668para 193.23.xxx.xx:6668, mas isso é só teoria.

Tentei criar um pequeno script do PowerShell para renomear vários arquivos com nomes semelhantes babebibobu (ver.2.0).xlsxem uma pasta e subpastas.

Quero remover o (ver.X.X)de cada nome de arquivo.

Eu tentei este:

Get-ChildItem -Path "c:\test" -Recurse -Include "* (ver*.*).*" | 
    Rename-Item -NewName { $_.Name -replace " (ver*.*)","" }

mas o nome do arquivo se torna babebibobu ().xlsx.

Eu tenho uma coleção. Muitas threads devem ser capazes de ler dela ao mesmo tempo, mas apenas uma thread deve ser capaz de escrever nela por vez, e somente quando não estiver sendo lida. O ReentrantReadWriteLock do Java parece perfeito para isso.

No entanto, estou confuso sobre como escrever o iterador para a coleção. O iterador deve obter o bloqueio de leitura quando ele começa. Mas não consigo descobrir como garantir que ele será desbloqueado no caso em que o iterador nunca terminou.

Aqui está um exemplo de código que é apenas um wrapper em torno de um iterador normal que bloqueia e desbloqueia:

import java.util.Iterator;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;

public class ReadLockIterator<T> implements Iterator<T> {
    
    private final Lock lock;
    private final Iterator<T> iterator;
    
    public ReadLockIterator(ReadWriteLock lock, Iterator<T> iterator) {
        this.lock = lock.readLock();
        this.iterator = iterator;
        this.lock.lock();
    }
    
    @Override
    public boolean hasNext() {
        return iterator.hasNext();
    }

    @Override
    public T next() {
        try {
            return iterator.next();
        }
        finally {
            if(!hasNext())
                lock.unlock();
        }
    }
}

Isso funcionará bem, desde que o usuário obtenha todos os elementos do iterador. Mas o que acontece se o usuário não fizer isso? Como posso garantir que o bloqueio será eventualmente liberado, mesmo que alguns elementos nunca sejam lidos do iterador?

Meu primeiro pensamento foi colocar uma segunda verificação no finalize()método do iterador, mas então li que finalize não deve ser usado para desbloquear.

Qual é a melhor maneira de lidar com isso?

Estou limitado ao C++17. Preciso fazer uma estrutura de árvore (não necessariamente binária) que possa ser profundamente copiada em 2 clones independentes. Atualmente, tenho uma Nodeclasse de interface onde há 2 implementações:

1. Uma Operationclasse contém um enum representando a operação booleana a ser realizada em seus std::vector<std::unique_ptr<Node>>operandos. Esses constituem os ramos na árvore.

2. Uma Conditionclasse contém os dados que serão comparados quando for dito para avaliar. Eles compõem as folhas na árvore.

Por fim, tenho uma Eventclasse com a std::unique_ptrque aponta para a raiz Nodedesta árvore. Tanto Operationan quanto Conditionpodem ser a raiz da árvore.

Tenho seguido esta postagem do blog em relação à clonagem adequada de um std::unique_ptr, mas não sei bem como manter a parte polimórfica dos construtores de cópia das classes Eventand Operation. Ter esses construtores de cópia é uma parte inerente do meu problema?

#include <algorithm>
#include <memory>
#include <string>
#include <vector>

namespace tree
{
struct Node
{
    // Virtual clone function to make a new std::unique_ptr
    // with a copy of the contents of the old std::unique_ptr
    // Both std::unique_ptrs will be independent of each other
    virtual std::unique_ptr<Node> clone() const = 0;

    std::string name;
};

enum class Boolean
{
    And,
    Or,
    Xor
};

struct Operation : public Node
{
    // Copy constructor (because copying a std::vector is non-trivial)
    // that will allocate a new std::vector of the same size and clone
    // new std::unique_ptrs from the other std::vector
    Operation(const Operation &other) : op(other.op), nodes(other.nodes.size())
    {
        std::transform(other.nodes.cbegin(), other.nodes.cend(), nodes.begin(),
            [](const auto &old) {
                // This line has the compilation error because Node is abstract,
                // but I need this for the polymorphism, correct?
                return op ? std::make_unique<Node>(old->clone()) : nullptr;
            });
    }
    
    // Clones this class
    virtual std::unique_ptr<Node> clone() const override
    {
        return std::make_unique<Operation>(*this);
    }
    
    Boolean op;
    // Can hold any number of other Operation or Condition objects
    std::vector<std::unique_ptr<Node>> nodes;
};

struct Condition : public Node
{
    // Clones this class
    virtual std::unique_ptr<Node> clone() const override
    {
        return std::make_unique<Condition>(*this);
    }
    
    int datum;
};

struct Event
{
    Event(std::string name) : name(name) {}
    // This line has the same compilation error
    Event(const Event &other) : name(other.name), root(std::make_unique<Node>(other.root->clone())) {}
    std::string name;
    std::unique_ptr<Node> root;
};
} // tree

Eu tinha um projeto Next 14.2.3 funcionando perfeitamente, que tive que fazer downgrade para 14.1.4 devido a um problema com agora-rtm-sdk. Mas depois de fazer downgrade, todo meu CSS meio que desapareceu. Como posso consertar isso?

Este é meu arquivo tailwind.config.ts

import type { Config } from "tailwindcss";
import daisyui from "daisyui";

const config: Config = {
  daisyui: {
    themes: [
      {
        mytheme: {
          primary: "#E84644",
          secondary: "#111111",
          "base-200": "#111111",
          "base-100": "#292929",
          success: "#24B833",
          info: "#1E1E1E"
        },
      },
    ],
  },
  content: [
    "./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
    "./src/Components/**/*.{js,ts,jsx,tsx,mdx}",
    "./src/app/**/*.{js,ts,jsx,tsx,mdx}",
  ],
  theme: {
    extend: {
      backgroundImage: {
        "gradient-radial": "radial-gradient(var(--tw-gradient-stops))",
        "gradient-conic":
          "conic-gradient(from 180deg at 50% 50%, var(--tw-gradient-stops))",
      },
    },
  },
  plugins: [daisyui],
};
export default config;

arquivo postcss.config.mjs

/** @type {import('postcss-load-config').Config} */
const config = {
  plugins: {
    tailwindcss: {},
  },
};

export default config;

arquivo globals.css

@tailwind base;
@tailwind components;
@tailwind utilities;

o arquivo layout.tsx raiz

import type { Metadata } from "next";
import { Poppins } from "next/font/google";
import "../globals.css";
import Navbar from "@/Components/Desktop/Navbar/Navbar";

const poppins = Poppins({
  weight: ["100", "200", "300", "400", "500", "600", "700", "800", "900"],
  subsets: ["latin"],
});

export const metadata: Metadata = {
  title: "Stranger Hub",
  description: "Generated by create next app",
};

export default function RootLayout({
  children,
}: Readonly<{
  children: React.ReactNode;
}>) {
  return (
    <html lang="en" data-theme="dark">
      <body className={poppins.className}>
        <Navbar />
        {children}
      </body>
    </html>
  );
}

Estou trabalhando na Jetpack Composeinterface do usuário em Android. Tenho um seguinte Boxque mostra um Text.

@Preview
@Composable
fun MyText(modifier: Modifier = Modifier)
{
    Box(modifier = Modifier.heightIn(max = 94.dp).widthIn(max = 270.dp)
        .clip(shape = RoundedCornerShape(20.dp))
        .border(
             width = 1.dp,
             color = Color.Green,
             shape = RoundedCornerShape(20.dp)
        )
        .padding(horizontal = 20.dp, vertical = 8.dp)) {
        Text(
            text = "Learn how to use Compose effectively",
            overflow = TextOverflow.Ellipsis,
            maxLines = 3,
            fontSize = 15.sp,
            fontWeight = FontWeight.W400,
            color = Color.Red
        )
    }
}

Ele produz saída anexada. Como você pode ver, "efetivamente" muda para a próxima linha devido a restrições de largura, mas deixa muito espaço vazio depois de "Compose" na primeira linha. Existe uma maneira de remover esse espaço extra restante para que a largura geral seja reduzida?

Estou usando Midnight e aprendendo compact. Espero obter algum esclarecimento sobre a persistentHashfunção ( export declare function persistentHash<a>(rt_type: CompactType<a>, value: a): Uint8Array;) , especialmente parart_type

É possível fazer o mesmo hashing no Compact no lado do cliente? Pode persistentHashser usado para fazer a mesma coisa?

export enum Role {
    Owner,
    None
};    
const roleHash = persistent_hash<Vector<1, Role>>([Role.Owner]);